From 764af0e78106eb21f4f05d2f0eac73954de364c1 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 Sep 2017 11:05:40 -0700 Subject: [PATCH 01/26] Added tests and accepted baselines. --- src/harness/unittests/printer.ts | 23 +++++++++++++++++++ ...tsNodeCorrectly.emptyGlobalAugmentation.js | 1 + ...yGlobalAugmentationWithNoDeclareKeyword.js | 1 + 3 files changed, 25 insertions(+) create mode 100644 tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js create mode 100644 tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js diff --git a/src/harness/unittests/printer.ts b/src/harness/unittests/printer.ts index 825bfddbb4a..2bbc19881a3 100644 --- a/src/harness/unittests/printer.ts +++ b/src/harness/unittests/printer.ts @@ -110,6 +110,29 @@ namespace ts { createSourceFile("source.ts", "", ScriptTarget.ES2015) )); + + printsCorrectly("emptyGlobalAugmentation", {}, printer => printer.printNode( + EmitHint.Unspecified, + createModuleDeclaration( + /*decorators*/ undefined, + /*modifiers*/ [createToken(SyntaxKind.DeclareKeyword)], + createIdentifier("global"), + createModuleBlock(emptyArray), + NodeFlags.GlobalAugmentation), + createSourceFile("source.ts", "", ScriptTarget.ES2015) + )); + + printsCorrectly("emptyGlobalAugmentationWithNoDeclareKeyword", {}, printer => printer.printNode( + EmitHint.Unspecified, + createModuleDeclaration( + /*decorators*/ undefined, + /*modifiers*/ undefined, + createIdentifier("global"), + createModuleBlock(emptyArray), + NodeFlags.GlobalAugmentation), + createSourceFile("source.ts", "", ScriptTarget.ES2015) + )); + // https://github.com/Microsoft/TypeScript/issues/15971 printsCorrectly("classWithOptionalMethodAndProperty", {}, printer => printer.printNode( EmitHint.Unspecified, diff --git a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js new file mode 100644 index 00000000000..2a8c3b88e16 --- /dev/null +++ b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js @@ -0,0 +1 @@ +declare module global { } \ No newline at end of file diff --git a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js new file mode 100644 index 00000000000..4cc10f41f8f --- /dev/null +++ b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js @@ -0,0 +1 @@ +module global { } \ No newline at end of file From 979295b21b10989328e851264a14460db49fadd7 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 Sep 2017 12:15:27 -0700 Subject: [PATCH 02/26] Force 'declare' modifiers and correct global augmentation emit. --- src/compiler/emitter.ts | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index 502329bbd84..f98533628d0 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1862,8 +1862,19 @@ namespace ts { } function emitModuleDeclaration(node: ModuleDeclaration) { - emitModifiers(node, node.modifiers); - write(node.flags & NodeFlags.Namespace ? "namespace " : "module "); + if (node.flags & NodeFlags.GlobalAugmentation) { + if (!hasModifier(node, ModifierFlags.Ambient)) { + // Always emit a 'declare' keyword in case it wasn't provided by a factory function call. + write("declare "); + } + else { + emitModifiers(node, node.modifiers); + } + } + else { + emitModifiers(node, node.modifiers); + write(node.flags & NodeFlags.Namespace ? "namespace " : "module "); + } emit(node.name); let body = node.body; From d30c3dcb4d06999ac3b28efb8659a0377bd2a9c1 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 21 Sep 2017 12:15:42 -0700 Subject: [PATCH 03/26] Accepted baselines. --- .../printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js | 2 +- ...NodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js index 2a8c3b88e16..cdbc9e5766e 100644 --- a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js +++ b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentation.js @@ -1 +1 @@ -declare module global { } \ No newline at end of file +declare global { } \ No newline at end of file diff --git a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js index 4cc10f41f8f..cdbc9e5766e 100644 --- a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js +++ b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js @@ -1 +1 @@ -module global { } \ No newline at end of file +declare global { } \ No newline at end of file From 30839378ac593386fc0a2a88512e2d26c38f3a24 Mon Sep 17 00:00:00 2001 From: Andy Date: Thu, 21 Sep 2017 14:42:13 -0700 Subject: [PATCH 04/26] Remove unnecessary 'tryParse' (#18663) --- src/compiler/parser.ts | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 766d53cb433..5746a3c7446 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -6486,14 +6486,8 @@ namespace ts { } function tryParseTypeExpression(): JSDocTypeExpression | undefined { - return tryParse(() => { - skipWhitespace(); - if (token() !== SyntaxKind.OpenBraceToken) { - return undefined; - } - - return parseJSDocTypeExpression(); - }); + skipWhitespace(); + return token() === SyntaxKind.OpenBraceToken ? parseJSDocTypeExpression() : undefined; } function parseBracketNameInPropertyAndParamTag(): { name: EntityName, isBracketed: boolean } { From ffa1ea72c12563ccbc0bb1ecce78dd5631b0e8fc Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 22 Sep 2017 00:12:37 -0700 Subject: [PATCH 05/26] Just always print out modifiers for global augmentations. Apparently, they don't always need them! --- src/compiler/emitter.ts | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) mode change 100644 => 100755 src/compiler/emitter.ts diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts old mode 100644 new mode 100755 index f98533628d0..d458e7e5ef5 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -1862,17 +1862,8 @@ namespace ts { } function emitModuleDeclaration(node: ModuleDeclaration) { - if (node.flags & NodeFlags.GlobalAugmentation) { - if (!hasModifier(node, ModifierFlags.Ambient)) { - // Always emit a 'declare' keyword in case it wasn't provided by a factory function call. - write("declare "); - } - else { - emitModifiers(node, node.modifiers); - } - } - else { - emitModifiers(node, node.modifiers); + emitModifiers(node, node.modifiers); + if (~node.flags & NodeFlags.GlobalAugmentation) { write(node.flags & NodeFlags.Namespace ? "namespace " : "module "); } emit(node.name); From 555718ef32d9128e3dc7ec515c01682b409a5ff6 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 22 Sep 2017 00:13:31 -0700 Subject: [PATCH 06/26] Accepted baselines. --- ...NodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js index cdbc9e5766e..a5315a0c0c4 100644 --- a/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js +++ b/tests/baselines/reference/printerApi/printsNodeCorrectly.emptyGlobalAugmentationWithNoDeclareKeyword.js @@ -1 +1 @@ -declare global { } \ No newline at end of file +global { } \ No newline at end of file From 1a383ec29066b400de55426bd6fc6fdf47402563 Mon Sep 17 00:00:00 2001 From: Andy Date: Fri, 22 Sep 2017 07:09:29 -0700 Subject: [PATCH 07/26] Remove unnecessary "@internal" (#18665) --- src/compiler/parser.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 5746a3c7446..98483823ec3 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -6135,7 +6135,6 @@ namespace ts { } // Parses out a JSDoc type expression. - /* @internal */ export function parseJSDocTypeExpression(): JSDocTypeExpression { const result = createNode(SyntaxKind.JSDocTypeExpression, scanner.getTokenPos()); From 7e002aeb7b08b2ee9ca837de79dce5f8e2ba969e Mon Sep 17 00:00:00 2001 From: Andy Date: Fri, 22 Sep 2017 08:49:56 -0700 Subject: [PATCH 08/26] Avoid calling `indexOf` when checking array element types (#18619) * Avoid calling `indexOf` when checking array element types * Add 'indexOfNode' and use it in cases which may handle long lists. (#18635) * Fix bug where contextual type was not reused if undefined --- src/compiler/checker.ts | 39 +++++++++++++++++++++---------------- src/compiler/utilities.ts | 12 ++++++++++++ src/services/textChanges.ts | 4 ++-- src/services/utilities.ts | 2 +- 4 files changed, 37 insertions(+), 20 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index e00465caa14..b135b52f6a9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -13198,16 +13198,11 @@ namespace ts { // the type of the property with the numeric name N in T, if one exists. Otherwise, if T has a numeric index signature, // it is the type of the numeric index signature in T. Otherwise, in ES6 and higher, the contextual type is the iterated // type of T. - function getContextualTypeForElementExpression(node: Expression): Type { - const arrayLiteral = node.parent; - const type = getApparentTypeOfContextualType(arrayLiteral); - if (type) { - const index = indexOf(arrayLiteral.elements, node); - return getTypeOfPropertyOfContextualType(type, "" + index as __String) - || getIndexTypeOfContextualType(type, IndexKind.Number) - || getIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterables*/ false, /*checkAssignability*/ false); - } - return undefined; + function getContextualTypeForElementExpression(arrayContextualType: Type | undefined, index: number): Type | undefined { + return arrayContextualType && ( + getTypeOfPropertyOfContextualType(arrayContextualType, "" + index as __String) + || getIndexTypeOfContextualType(arrayContextualType, IndexKind.Number) + || getIteratedTypeOrElementType(arrayContextualType, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterables*/ false, /*checkAssignability*/ false)); } // In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type. @@ -13321,8 +13316,11 @@ namespace ts { return getContextualTypeForObjectLiteralElement(parent); case SyntaxKind.SpreadAssignment: return getApparentTypeOfContextualType(parent.parent as ObjectLiteralExpression); - case SyntaxKind.ArrayLiteralExpression: - return getContextualTypeForElementExpression(node); + case SyntaxKind.ArrayLiteralExpression: { + const arrayLiteral = parent; + const type = getApparentTypeOfContextualType(arrayLiteral); + return getContextualTypeForElementExpression(type, indexOfNode(arrayLiteral.elements, node)); + } case SyntaxKind.ConditionalExpression: return getContextualTypeForConditionalOperand(node); case SyntaxKind.TemplateSpan: @@ -13451,12 +13449,14 @@ namespace ts { (node.kind === SyntaxKind.BinaryExpression && (node).operatorToken.kind === SyntaxKind.EqualsToken); } - function checkArrayLiteral(node: ArrayLiteralExpression, checkMode?: CheckMode): Type { + function checkArrayLiteral(node: ArrayLiteralExpression, checkMode: CheckMode | undefined): Type { const elements = node.elements; let hasSpreadElement = false; const elementTypes: Type[] = []; const inDestructuringPattern = isAssignmentTarget(node); - for (const e of elements) { + const contextualType = getApparentTypeOfContextualType(node); + for (let index = 0; index < elements.length; index++) { + const e = elements[index]; if (inDestructuringPattern && e.kind === SyntaxKind.SpreadElement) { // Given the following situation: // var c: {}; @@ -13478,7 +13478,8 @@ namespace ts { } } else { - const type = checkExpressionForMutableLocation(e, checkMode); + const elementContextualType = getContextualTypeForElementExpression(contextualType, index); + const type = checkExpressionForMutableLocation(e, checkMode, elementContextualType); elementTypes.push(type); } hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElement; @@ -18023,9 +18024,13 @@ namespace ts { return false; } - function checkExpressionForMutableLocation(node: Expression, checkMode?: CheckMode): Type { + function checkExpressionForMutableLocation(node: Expression, checkMode: CheckMode, contextualType?: Type): Type { + if (arguments.length === 2) { + contextualType = getContextualType(node); + } const type = checkExpression(node, checkMode); - return isTypeAssertion(node) || isLiteralContextualType(getContextualType(node)) ? type : getWidenedLiteralType(type); + const shouldWiden = isTypeAssertion(node) || isLiteralContextualType(contextualType); + return shouldWiden ? type : getWidenedLiteralType(type); } function checkPropertyAssignment(node: PropertyAssignment, checkMode?: CheckMode): Type { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index f3b40c702b6..ede4c5a45e9 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -321,6 +321,18 @@ namespace ts { return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia); } + /** + * Note: it is expected that the `nodeArray` and the `node` are within the same file. + * For example, searching for a `SourceFile` in a `SourceFile[]` wouldn't work. + */ + export function indexOfNode(nodeArray: ReadonlyArray, node: Node) { + return binarySearch(nodeArray, node, compareNodePos); + } + + function compareNodePos({ pos: aPos }: Node, { pos: bPos}: Node) { + return aPos < bPos ? Comparison.LessThan : bPos < aPos ? Comparison.GreaterThan : Comparison.EqualTo; + } + /** * Gets flags that control emit behavior of a node. */ diff --git a/src/services/textChanges.ts b/src/services/textChanges.ts index 5a01752f38e..9e4c2ed3a60 100644 --- a/src/services/textChanges.ts +++ b/src/services/textChanges.ts @@ -226,7 +226,7 @@ namespace ts.textChanges { Debug.fail("node is not a list element"); return this; } - const index = containingList.indexOf(node); + const index = indexOfNode(containingList, node); if (index < 0) { return this; } @@ -358,7 +358,7 @@ namespace ts.textChanges { Debug.fail("node is not a list element"); return this; } - const index = containingList.indexOf(after); + const index = indexOfNode(containingList, after); if (index < 0) { return this; } diff --git a/src/services/utilities.ts b/src/services/utilities.ts index c3a1d5d571d..3dd3ddd456e 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -597,7 +597,7 @@ namespace ts { } const children = list.getChildren(); - const listItemIndex = indexOf(children, node); + const listItemIndex = indexOfNode(children, node); return { listItemIndex, From f7d8081ab3eae28292c51aa039a609c5912d8a6b Mon Sep 17 00:00:00 2001 From: Andy Date: Fri, 22 Sep 2017 09:39:22 -0700 Subject: [PATCH 09/26] Unify duplicate `getNameOfSymbol` functions (#18618) --- src/compiler/checker.ts | 47 +++++-------------- .../reference/declarationQuotedMembers.types | 6 +-- 2 files changed, 16 insertions(+), 37 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b135b52f6a9..9f326aec7dd 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2425,15 +2425,6 @@ namespace ts { } }; - interface NodeBuilderContext { - enclosingDeclaration: Node | undefined; - flags: NodeBuilderFlags | undefined; - - // State - encounteredError: boolean; - symbolStack: Symbol[] | undefined; - } - function createNodeBuilderContext(enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): NodeBuilderContext { return { enclosingDeclaration, @@ -3027,30 +3018,6 @@ namespace ts { } } } - - function getNameOfSymbol(symbol: Symbol, context: NodeBuilderContext): string { - const declaration = firstOrUndefined(symbol.declarations); - if (declaration) { - const name = getNameOfDeclaration(declaration); - if (name) { - return declarationNameToString(name); - } - if (declaration.parent && declaration.parent.kind === SyntaxKind.VariableDeclaration) { - return declarationNameToString((declaration.parent).name); - } - if (!context.encounteredError && !(context.flags & NodeBuilderFlags.AllowAnonymousIdentifier)) { - context.encounteredError = true; - } - switch (declaration.kind) { - case SyntaxKind.ClassExpression: - return "(Anonymous class)"; - case SyntaxKind.FunctionExpression: - case SyntaxKind.ArrowFunction: - return "(Anonymous function)"; - } - } - return unescapeLeadingUnderscores(symbol.escapedName); - } } function typePredicateToString(typePredicate: TypePredicate, enclosingDeclaration?: Declaration, flags?: TypeFormatFlags): string { @@ -3115,7 +3082,16 @@ namespace ts { return type.flags & TypeFlags.StringLiteral ? '"' + escapeString((type).value) + '"' : "" + (type).value; } - function getNameOfSymbol(symbol: Symbol): string { + interface NodeBuilderContext { + enclosingDeclaration: Node | undefined; + flags: NodeBuilderFlags | undefined; + + // State + encounteredError: boolean; + symbolStack: Symbol[] | undefined; + } + + function getNameOfSymbol(symbol: Symbol, context?: NodeBuilderContext): string { if (symbol.declarations && symbol.declarations.length) { const declaration = symbol.declarations[0]; const name = getNameOfDeclaration(declaration); @@ -3125,6 +3101,9 @@ namespace ts { if (declaration.parent && declaration.parent.kind === SyntaxKind.VariableDeclaration) { return declarationNameToString((declaration.parent).name); } + if (context && !context.encounteredError && !(context.flags & NodeBuilderFlags.AllowAnonymousIdentifier)) { + context.encounteredError = true; + } switch (declaration.kind) { case SyntaxKind.ClassExpression: return "(Anonymous class)"; diff --git a/tests/baselines/reference/declarationQuotedMembers.types b/tests/baselines/reference/declarationQuotedMembers.types index c9f6c047b7e..32ffa069977 100644 --- a/tests/baselines/reference/declarationQuotedMembers.types +++ b/tests/baselines/reference/declarationQuotedMembers.types @@ -1,9 +1,9 @@ === tests/cases/compiler/declarationQuotedMembers.ts === export declare const mapped: { [K in 'a-b-c']: number } ->mapped : { a-b-c: number; } +>mapped : { "a-b-c": number; } >K : K export const example = mapped; ->example : { a-b-c: number; } ->mapped : { a-b-c: number; } +>example : { "a-b-c": number; } +>mapped : { "a-b-c": number; } From a4b5870a521bfac6902c14ca9b256ee90f0d932d Mon Sep 17 00:00:00 2001 From: Andy Date: Fri, 22 Sep 2017 09:39:46 -0700 Subject: [PATCH 10/26] Cleanups in formattingScanner.ts (#18599) * Cleanups in formattingScanner.ts * Move switch statement to function * Fix assertions --- src/services/formatting/formattingScanner.ts | 121 +++++++++---------- 1 file changed, 55 insertions(+), 66 deletions(-) diff --git a/src/services/formatting/formattingScanner.ts b/src/services/formatting/formattingScanner.ts index d69fb141ba1..f126327fa06 100644 --- a/src/services/formatting/formattingScanner.ts +++ b/src/services/formatting/formattingScanner.ts @@ -53,28 +53,19 @@ namespace ts.formatting { return res; function advance(): void { - Debug.assert(scanner !== undefined, "Scanner should be present"); - lastTokenInfo = undefined; const isStarted = scanner.getStartPos() !== startPos; if (isStarted) { - if (trailingTrivia) { - Debug.assert(trailingTrivia.length !== 0); - wasNewLine = lastOrUndefined(trailingTrivia).kind === SyntaxKind.NewLineTrivia; - } - else { - wasNewLine = false; - } + wasNewLine = trailingTrivia && lastOrUndefined(trailingTrivia)!.kind === SyntaxKind.NewLineTrivia; + } + else { + scanner.scan(); } leadingTrivia = undefined; trailingTrivia = undefined; - if (!isStarted) { - scanner.scan(); - } - let pos = scanner.getStartPos(); // Read leading trivia and token @@ -94,25 +85,20 @@ namespace ts.formatting { pos = scanner.getStartPos(); - if (!leadingTrivia) { - leadingTrivia = []; - } - leadingTrivia.push(item); + leadingTrivia = append(leadingTrivia, item); } savedPos = scanner.getStartPos(); } function shouldRescanGreaterThanToken(node: Node): boolean { - if (node) { - switch (node.kind) { - case SyntaxKind.GreaterThanEqualsToken: - case SyntaxKind.GreaterThanGreaterThanEqualsToken: - case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: - case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: - case SyntaxKind.GreaterThanGreaterThanToken: - return true; - } + switch (node.kind) { + case SyntaxKind.GreaterThanEqualsToken: + case SyntaxKind.GreaterThanGreaterThanEqualsToken: + case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: + case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: + case SyntaxKind.GreaterThanGreaterThanToken: + return true; } return false; @@ -134,7 +120,7 @@ namespace ts.formatting { } function shouldRescanJsxText(node: Node): boolean { - return node && node.kind === SyntaxKind.JsxText; + return node.kind === SyntaxKind.JsxText; } function shouldRescanSlashToken(container: Node): boolean { @@ -151,16 +137,7 @@ namespace ts.formatting { } function readTokenInfo(n: Node): TokenInfo { - Debug.assert(scanner !== undefined); - - if (!isOnToken()) { - // scanner is not on the token (either advance was not called yet or scanner is already past the end position) - return { - leadingTrivia, - trailingTrivia: undefined, - token: undefined - }; - } + Debug.assert(isOnToken()); // normally scanner returns the smallest available token // check the kind of context node to determine if scanner should have more greedy behavior and consume more text. @@ -194,33 +171,7 @@ namespace ts.formatting { scanner.scan(); } - let currentToken = scanner.getToken(); - - if (expectedScanAction === ScanAction.RescanGreaterThanToken && currentToken === SyntaxKind.GreaterThanToken) { - currentToken = scanner.reScanGreaterToken(); - Debug.assert(n.kind === currentToken); - lastScanAction = ScanAction.RescanGreaterThanToken; - } - else if (expectedScanAction === ScanAction.RescanSlashToken && startsWithSlashToken(currentToken)) { - currentToken = scanner.reScanSlashToken(); - Debug.assert(n.kind === currentToken); - lastScanAction = ScanAction.RescanSlashToken; - } - else if (expectedScanAction === ScanAction.RescanTemplateToken && currentToken === SyntaxKind.CloseBraceToken) { - currentToken = scanner.reScanTemplateToken(); - lastScanAction = ScanAction.RescanTemplateToken; - } - else if (expectedScanAction === ScanAction.RescanJsxIdentifier) { - currentToken = scanner.scanJsxIdentifier(); - lastScanAction = ScanAction.RescanJsxIdentifier; - } - else if (expectedScanAction === ScanAction.RescanJsxText) { - currentToken = scanner.reScanJsxToken(); - lastScanAction = ScanAction.RescanJsxText; - } - else { - lastScanAction = ScanAction.Scan; - } + let currentToken = getNextToken(n, expectedScanAction); const token: TextRangeWithKind = { pos: scanner.getStartPos(), @@ -261,9 +212,47 @@ namespace ts.formatting { return fixTokenKind(lastTokenInfo, n); } - function isOnToken(): boolean { - Debug.assert(scanner !== undefined); + function getNextToken(n: Node, expectedScanAction: ScanAction): SyntaxKind { + const token = scanner.getToken(); + lastScanAction = ScanAction.Scan; + switch (expectedScanAction) { + case ScanAction.RescanGreaterThanToken: + if (token === SyntaxKind.GreaterThanToken) { + lastScanAction = ScanAction.RescanGreaterThanToken; + const newToken = scanner.reScanGreaterToken(); + Debug.assert(n.kind === newToken); + return newToken; + } + break; + case ScanAction.RescanSlashToken: + if (startsWithSlashToken(token)) { + lastScanAction = ScanAction.RescanSlashToken; + const newToken = scanner.reScanSlashToken(); + Debug.assert(n.kind === newToken); + return newToken; + } + break; + case ScanAction.RescanTemplateToken: + if (token === SyntaxKind.CloseBraceToken) { + lastScanAction = ScanAction.RescanTemplateToken; + return scanner.reScanTemplateToken(); + } + break; + case ScanAction.RescanJsxIdentifier: + lastScanAction = ScanAction.RescanJsxIdentifier; + return scanner.scanJsxIdentifier(); + case ScanAction.RescanJsxText: + lastScanAction = ScanAction.RescanJsxText; + return scanner.reScanJsxToken(); + case ScanAction.Scan: + break; + default: + Debug.assertNever(expectedScanAction); + } + return token; + } + function isOnToken(): boolean { const current = lastTokenInfo ? lastTokenInfo.token.kind : scanner.getToken(); const startPos = lastTokenInfo ? lastTokenInfo.token.pos : scanner.getStartPos(); return startPos < endPos && current !== SyntaxKind.EndOfFileToken && !isTrivia(current); From 72c8b804da98ea64376ad3981f0ad167d4d19934 Mon Sep 17 00:00:00 2001 From: Andy Date: Fri, 22 Sep 2017 10:42:02 -0700 Subject: [PATCH 11/26] Use JSDoc `@type` tag type cast as a contextual type (#18690) * Use JSDoc `@type` tag type cast as a contextual type * Suggested changes --- src/compiler/checker.ts | 17 ++++++++--------- src/compiler/utilities.ts | 9 +++++++-- .../fourslash/completionsJsdocTypeTagCast.ts | 7 +++++++ 3 files changed, 22 insertions(+), 11 deletions(-) create mode 100644 tests/cases/fourslash/completionsJsdocTypeTagCast.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9f326aec7dd..5c835582da0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -13305,8 +13305,11 @@ namespace ts { case SyntaxKind.TemplateSpan: Debug.assert(parent.parent.kind === SyntaxKind.TemplateExpression); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case SyntaxKind.ParenthesizedExpression: - return getContextualType(parent); + case SyntaxKind.ParenthesizedExpression: { + // Like in `checkParenthesizedExpression`, an `/** @type {xyz} */` comment before a parenthesized expression acts as a type cast. + const tag = isInJavaScriptFile(parent) ? getJSDocTypeTag(parent) : undefined; + return tag ? getTypeFromTypeNode(tag.typeExpression.type) : getContextualType(parent); + } case SyntaxKind.JsxExpression: return getContextualTypeForJsxExpression(parent); case SyntaxKind.JsxAttribute: @@ -18127,13 +18130,9 @@ namespace ts { } function checkParenthesizedExpression(node: ParenthesizedExpression, checkMode?: CheckMode): Type { - if (isInJavaScriptFile(node) && node.jsDoc) { - const typecasts = flatMap(node.jsDoc, doc => filter(doc.tags, tag => tag.kind === SyntaxKind.JSDocTypeTag && !!(tag as JSDocTypeTag).typeExpression && !!(tag as JSDocTypeTag).typeExpression.type)); - if (typecasts && typecasts.length) { - // We should have already issued an error if there were multiple type jsdocs - const cast = typecasts[0] as JSDocTypeTag; - return checkAssertionWorker(cast, cast.typeExpression.type, node.expression, checkMode); - } + const tag = isInJavaScriptFile(node) ? getJSDocTypeTag(node) : undefined; + if (tag) { + return checkAssertionWorker(tag, tag.typeExpression.type, node.expression, checkMode); } return checkExpression(node.expression, checkMode); } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index ede4c5a45e9..674215b0583 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -4091,9 +4091,14 @@ namespace ts { return getFirstJSDocTag(node, SyntaxKind.JSDocTemplateTag) as JSDocTemplateTag; } - /** Gets the JSDoc type tag for the node if present */ + /** Gets the JSDoc type tag for the node if present and valid */ export function getJSDocTypeTag(node: Node): JSDocTypeTag | undefined { - return getFirstJSDocTag(node, SyntaxKind.JSDocTypeTag) as JSDocTypeTag; + // We should have already issued an error if there were multiple type jsdocs, so just use the first one. + const tag = getFirstJSDocTag(node, SyntaxKind.JSDocTypeTag) as JSDocTypeTag; + if (tag && tag.typeExpression && tag.typeExpression.type) { + return tag; + } + return undefined; } /** diff --git a/tests/cases/fourslash/completionsJsdocTypeTagCast.ts b/tests/cases/fourslash/completionsJsdocTypeTagCast.ts new file mode 100644 index 00000000000..822069feb53 --- /dev/null +++ b/tests/cases/fourslash/completionsJsdocTypeTagCast.ts @@ -0,0 +1,7 @@ +/// + +// @allowJs: true +// @Filename: /a.js +////const x = /** @type {{ s: string }} */ ({ /**/ }); + +verify.completionsAt("", ["s", "x"]); From 2399bac377a6ba28f1b0648b987203d5badf3a84 Mon Sep 17 00:00:00 2001 From: Andy Date: Fri, 22 Sep 2017 10:45:43 -0700 Subject: [PATCH 12/26] Make it a parse error for an `@type` jsdoc tag to not include a type (#18664) * Make it a parse error for an `@type` jsdoc tag to not include a type * Rename parameter --- src/compiler/parser.ts | 10 +++++++--- src/harness/unittests/jsDocParsing.ts | 11 +++++------ 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 98483823ec3..3809a071421 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -6135,10 +6135,14 @@ namespace ts { } // Parses out a JSDoc type expression. - export function parseJSDocTypeExpression(): JSDocTypeExpression { + export function parseJSDocTypeExpression(): JSDocTypeExpression; + export function parseJSDocTypeExpression(requireBraces: true): JSDocTypeExpression | undefined; + export function parseJSDocTypeExpression(requireBraces?: boolean): JSDocTypeExpression | undefined { const result = createNode(SyntaxKind.JSDocTypeExpression, scanner.getTokenPos()); - parseExpected(SyntaxKind.OpenBraceToken); + if (!parseExpected(SyntaxKind.OpenBraceToken) && requireBraces) { + return undefined; + } result.type = doInsideOfContext(NodeFlags.JSDoc, parseType); parseExpected(SyntaxKind.CloseBraceToken); @@ -6595,7 +6599,7 @@ namespace ts { const result = createNode(SyntaxKind.JSDocTypeTag, atToken.pos); result.atToken = atToken; result.tagName = tagName; - result.typeExpression = tryParseTypeExpression(); + result.typeExpression = parseJSDocTypeExpression(/*mayBail*/ true); return finishNode(result); } diff --git a/src/harness/unittests/jsDocParsing.ts b/src/harness/unittests/jsDocParsing.ts index 0e6221567a2..209aaa48c19 100644 --- a/src/harness/unittests/jsDocParsing.ts +++ b/src/harness/unittests/jsDocParsing.ts @@ -139,6 +139,11 @@ namespace ts { `/** * @param */`); + + parsesIncorrectly("noType", +`/** +* @type +*/`); }); describe("parsesCorrectly", () => { @@ -148,12 +153,6 @@ namespace ts { */`); - parsesCorrectly("noType", -`/** - * @type - */`); - - parsesCorrectly("noReturnType", `/** * @return From d0fd964b694997d7d67849f3ff822b599cd057ab Mon Sep 17 00:00:00 2001 From: Filipe Silva Date: Fri, 22 Sep 2017 19:54:20 +0100 Subject: [PATCH 13/26] Fix getSourceFile return type (#18689) --- src/compiler/types.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 5347d7caaf0..4e5ca9f07e7 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -4095,8 +4095,8 @@ namespace ts { } export interface CompilerHost extends ModuleResolutionHost { - getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; - getSourceFileByPath?(fileName: string, path: Path, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; + getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile | undefined; + getSourceFileByPath?(fileName: string, path: Path, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile | undefined; getCancellationToken?(): CancellationToken; getDefaultLibFileName(options: CompilerOptions): string; getDefaultLibLocation?(): string; From 38905f46ce328b24b581399d7f364edbd834be76 Mon Sep 17 00:00:00 2001 From: Andy Date: Fri, 22 Sep 2017 14:07:07 -0700 Subject: [PATCH 14/26] Minor cleanup to symbolWalker (#18549) * Minor cleanup to symbolWalker * Undo inlining --- src/compiler/core.ts | 16 ++++++---- src/compiler/symbolWalker.ts | 58 +++++++++++++++++------------------- 2 files changed, 39 insertions(+), 35 deletions(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 84321b4b624..ffa010c6551 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -994,11 +994,6 @@ namespace ts { /** * Gets the owned, enumerable property keys of a map-like. - * - * NOTE: This is intended for use with MapLike objects. For Map objects, use - * Object.keys instead as it offers better performance. - * - * @param map A map-like. */ export function getOwnKeys(map: MapLike): string[] { const keys: string[] = []; @@ -1011,6 +1006,17 @@ namespace ts { return keys; } + export function getOwnValues(sparseArray: T[]): T[] { + const values: T[] = []; + for (const key in sparseArray) { + if (hasOwnProperty.call(sparseArray, key)) { + values.push(sparseArray[key]); + } + } + + return values; + } + /** Shims `Array.from`. */ export function arrayFrom(iterator: Iterator, map: (t: T) => U): U[]; export function arrayFrom(iterator: Iterator): T[]; diff --git a/src/compiler/symbolWalker.ts b/src/compiler/symbolWalker.ts index e20ef9f9d98..ac6b60bdc3e 100644 --- a/src/compiler/symbolWalker.ts +++ b/src/compiler/symbolWalker.ts @@ -14,21 +14,29 @@ namespace ts { return getSymbolWalker; function getSymbolWalker(accept: (symbol: Symbol) => boolean = () => true): SymbolWalker { - const visitedTypes = createMap(); // Key is id as string - const visitedSymbols = createMap(); // Key is id as string + const visitedTypes: Type[] = []; // Sparse array from id to type + const visitedSymbols: Symbol[] = []; // Sparse array from id to symbol return { walkType: type => { - visitedTypes.clear(); - visitedSymbols.clear(); - visitType(type); - return { visitedTypes: arrayFrom(visitedTypes.values()), visitedSymbols: arrayFrom(visitedSymbols.values()) }; + try { + visitType(type); + return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) }; + } + finally { + clear(visitedTypes); + clear(visitedSymbols); + } }, walkSymbol: symbol => { - visitedTypes.clear(); - visitedSymbols.clear(); - visitSymbol(symbol); - return { visitedTypes: arrayFrom(visitedTypes.values()), visitedSymbols: arrayFrom(visitedSymbols.values()) }; + try { + visitSymbol(symbol); + return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) }; + } + finally { + clear(visitedTypes); + clear(visitedSymbols); + } }, }; @@ -37,11 +45,10 @@ namespace ts { return; } - const typeIdString = type.id.toString(); - if (visitedTypes.has(typeIdString)) { + if (visitedTypes[type.id]) { return; } - visitedTypes.set(typeIdString, type); + visitedTypes[type.id] = type; // Reuse visitSymbol to visit the type's symbol, // but be sure to bail on recuring into the type if accept declines the symbol. @@ -79,18 +86,9 @@ namespace ts { } } - function visitTypeList(types: Type[]): void { - if (!types) { - return; - } - for (let i = 0; i < types.length; i++) { - visitType(types[i]); - } - } - function visitTypeReference(type: TypeReference): void { visitType(type.target); - visitTypeList(type.typeArguments); + forEach(type.typeArguments, visitType); } function visitTypeParameter(type: TypeParameter): void { @@ -98,7 +96,7 @@ namespace ts { } function visitUnionOrIntersectionType(type: UnionOrIntersectionType): void { - visitTypeList(type.types); + forEach(type.types, visitType); } function visitIndexType(type: IndexType): void { @@ -122,7 +120,7 @@ namespace ts { if (signature.typePredicate) { visitType(signature.typePredicate.type); } - visitTypeList(signature.typeParameters); + forEach(signature.typeParameters, visitType); for (const parameter of signature.parameters){ visitSymbol(parameter); @@ -133,8 +131,8 @@ namespace ts { function visitInterfaceType(interfaceT: InterfaceType): void { visitObjectType(interfaceT); - visitTypeList(interfaceT.typeParameters); - visitTypeList(getBaseTypes(interfaceT)); + forEach(interfaceT.typeParameters, visitType); + forEach(getBaseTypes(interfaceT), visitType); visitType(interfaceT.thisType); } @@ -161,11 +159,11 @@ namespace ts { if (!symbol) { return; } - const symbolIdString = getSymbolId(symbol).toString(); - if (visitedSymbols.has(symbolIdString)) { + const symbolId = getSymbolId(symbol); + if (visitedSymbols[symbolId]) { return; } - visitedSymbols.set(symbolIdString, symbol); + visitedSymbols[symbolId] = symbol; if (!accept(symbol)) { return true; } From 5f4436d43385b31743830f448a007b4cd7afe613 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 22 Sep 2017 14:44:26 -0700 Subject: [PATCH 15/26] Keep a small reserve of tasks to not-batch, so all threads can have always have an initial task (#18696) * Keep a small reserve of tasks to not-batch, so all threads can have an initial task" * Assign no weight to new tests, but still place them at the end of the list --- src/harness/parallel/host.ts | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/harness/parallel/host.ts b/src/harness/parallel/host.ts index 9f5ebdd790c..764e7635668 100644 --- a/src/harness/parallel/host.ts +++ b/src/harness/parallel/host.ts @@ -44,7 +44,8 @@ namespace Harness.Parallel.Host { console.log("Discovering tests..."); const discoverStart = +(new Date()); const { statSync }: { statSync(path: string): { size: number }; } = require("fs"); - const tasks: { runner: TestRunnerKind, file: string, size: number }[] = []; + let tasks: { runner: TestRunnerKind, file: string, size: number }[] = []; + const newTasks: { runner: TestRunnerKind, file: string, size: number }[] = []; const perfData = readSavedPerfData(); let totalCost = 0; let unknownValue: string | undefined; @@ -60,8 +61,10 @@ namespace Harness.Parallel.Host { const hashedName = hashName(runner.kind(), file); size = perfData[hashedName]; if (size === undefined) { - size = Number.MAX_SAFE_INTEGER; + size = 0; unknownValue = hashedName; + newTasks.push({ runner: runner.kind(), file, size }); + continue; } } tasks.push({ runner: runner.kind(), file, size }); @@ -69,6 +72,7 @@ namespace Harness.Parallel.Host { } } tasks.sort((a, b) => a.size - b.size); + tasks = tasks.concat(newTasks); // 1 fewer batches than threads to account for unittests running on the final thread const batchCount = runners.length === 1 ? workerCount : workerCount - 1; const packfraction = 0.9; @@ -174,7 +178,7 @@ namespace Harness.Parallel.Host { let scheduledTotal = 0; batcher: while (true) { for (let i = 0; i < batchCount; i++) { - if (tasks.length === 0) { + if (tasks.length <= workerCount) { // Keep a small reserve even in the suboptimally packed case console.log(`Suboptimal packing detected: no tests remain to be stolen. Reduce packing fraction from ${packfraction} to fix.`); break batcher; } @@ -213,7 +217,9 @@ namespace Harness.Parallel.Host { worker.send({ type: "batch", payload }); } else { // Unittest thread - send off just one test - worker.send({ type: "test", payload: tasks.pop() }); + const payload = tasks.pop(); + ts.Debug.assert(!!payload); // The reserve kept above should ensure there is always an initial task available, even in suboptimal scenarios + worker.send({ type: "test", payload }); } } } From 5353475fce854af66f64bf69da4735bbce75f58c Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Fri, 22 Sep 2017 15:52:04 -0700 Subject: [PATCH 16/26] Always collect type and symbol baselines (#18621) * Always generate type & symbol baselines * Accept changed shadowed baselines * Accept brand new type and symbol baselines * Allow `getTypeAtLocation` to return undefined in the type writer * Accept baselines which had missing type information * Bind container for dynamically names enum members so they may be printed * Accept type/symbol baselines for enums with computed members * First pass at reducing typeWriter memory overhead * Use generators to allow for type and symbol baselines with no cache * Accept new baselines for tests whose output was fixed by better newline splitting * Hard cap on number of declarations printed, cache declaration print text * handle differing newlines better still to handle RWC newlines * Lower abridging count, accept abridged baselines * Limit max RWC error output size, limit RWC type and symbol baseline input size * Move skip logic into type and symbol baseliner to streamline error handling * Accept removal of empty baselines * Canonicalize path earlier to handle odd paths in input files * Do canonicalization earlier still, also ensure parallel perf profiles for different targets do not trample one another * No need to pathify again --- .gitignore | 2 +- src/compiler/binder.ts | 8 +- src/harness/compilerRunner.ts | 2 +- src/harness/harness.ts | 116 +- src/harness/parallel/host.ts | 13 +- src/harness/runner.ts | 8 + src/harness/rwcRunner.ts | 8 +- src/harness/typeWriter.ts | 119 +- .../reference/ArrowFunction1.symbols | 6 + .../baselines/reference/ArrowFunction1.types | 8 + .../reference/ArrowFunction3.symbols | 6 + .../baselines/reference/ArrowFunction3.types | 8 + .../ArrowFunctionExpression1.symbols | 5 + .../reference/ArrowFunctionExpression1.types | 6 + ...leMemberThatUsesClassTypeParameter.symbols | 97 + ...duleMemberThatUsesClassTypeParameter.types | 103 + ...icClassStaticFunctionOfTheSameName.symbols | 38 + ...ericClassStaticFunctionOfTheSameName.types | 38 + ...icClassStaticFunctionOfTheSameName.symbols | 36 + ...ericClassStaticFunctionOfTheSameName.types | 36 + ...icFunctionUsingClassPrivateStatics.symbols | 37 + ...aticFunctionUsingClassPrivateStatics.types | 40 + ...nAndExportedFunctionThatShareAName.symbols | 47 + ...ionAndExportedFunctionThatShareAName.types | 55 + ...riableAndExportedVarThatShareAName.symbols | 47 + ...VariableAndExportedVarThatShareAName.types | 55 + ...AndModuleWithSameNameAndCommonRoot.symbols | 98 + ...ssAndModuleWithSameNameAndCommonRoot.types | 108 + ...ModuleWithSameNameAndCommonRootES6.symbols | 98 + ...ndModuleWithSameNameAndCommonRootES6.types | 108 + .../reference/ClassDeclaration10.symbols | 8 + .../reference/ClassDeclaration10.types | 8 + .../reference/ClassDeclaration11.symbols | 8 + .../reference/ClassDeclaration11.types | 8 + .../reference/ClassDeclaration13.symbols | 10 + .../reference/ClassDeclaration13.types | 10 + .../reference/ClassDeclaration14.symbols | 9 + .../reference/ClassDeclaration14.types | 9 + .../reference/ClassDeclaration15.symbols | 9 + .../reference/ClassDeclaration15.types | 9 + .../reference/ClassDeclaration21.symbols | 7 + .../reference/ClassDeclaration21.types | 7 + .../reference/ClassDeclaration22.symbols | 7 + .../reference/ClassDeclaration22.types | 7 + .../reference/ClassDeclaration24.symbols | 4 + .../reference/ClassDeclaration24.types | 4 + .../reference/ClassDeclaration25.symbols | 26 + .../reference/ClassDeclaration25.types | 26 + .../reference/ClassDeclaration26.symbols | 11 + .../reference/ClassDeclaration26.types | 13 + .../reference/ClassDeclaration8.symbols | 6 + .../reference/ClassDeclaration8.types | 6 + .../reference/ClassDeclaration9.symbols | 7 + .../reference/ClassDeclaration9.types | 7 + ...hInvalidConstOnPropertyDeclaration.symbols | 7 + ...ithInvalidConstOnPropertyDeclaration.types | 8 + .../DeclarationErrorsNoEmitOnError.symbols | 12 + .../DeclarationErrorsNoEmitOnError.types | 12 + .../reference/ES3For-ofTypeCheck1.symbols | 4 + .../reference/ES3For-ofTypeCheck1.types | 5 + .../reference/ES3For-ofTypeCheck4.symbols | 8 + .../reference/ES3For-ofTypeCheck4.types | 8 + tests/baselines/reference/ES5For-of1.symbols | 7 + tests/baselines/reference/ES5For-of1.types | 15 + tests/baselines/reference/ES5For-of12.symbols | 3 + tests/baselines/reference/ES5For-of12.types | 8 + tests/baselines/reference/ES5For-of17.symbols | 19 + tests/baselines/reference/ES5For-of17.types | 22 + tests/baselines/reference/ES5For-of20.symbols | 15 + tests/baselines/reference/ES5For-of20.types | 17 + tests/baselines/reference/ES5For-of22.symbols | 10 + tests/baselines/reference/ES5For-of22.types | 19 + tests/baselines/reference/ES5For-of23.symbols | 10 + tests/baselines/reference/ES5For-of23.types | 19 + tests/baselines/reference/ES5For-of26.symbols | 11 + tests/baselines/reference/ES5For-of26.types | 16 + tests/baselines/reference/ES5For-of27.symbols | 11 + tests/baselines/reference/ES5For-of27.types | 18 + tests/baselines/reference/ES5For-of28.symbols | 11 + tests/baselines/reference/ES5For-of28.types | 16 + tests/baselines/reference/ES5For-of29.symbols | 11 + tests/baselines/reference/ES5For-of29.types | 18 + tests/baselines/reference/ES5For-of30.symbols | 19 + tests/baselines/reference/ES5For-of30.types | 27 + tests/baselines/reference/ES5For-of31.symbols | 17 + tests/baselines/reference/ES5For-of31.types | 23 + tests/baselines/reference/ES5For-of33.symbols | 7 + tests/baselines/reference/ES5For-of33.types | 15 + tests/baselines/reference/ES5For-of34.symbols | 18 + tests/baselines/reference/ES5For-of34.types | 26 + tests/baselines/reference/ES5For-of35.symbols | 11 + tests/baselines/reference/ES5For-of35.types | 18 + tests/baselines/reference/ES5For-of36.symbols | 11 + tests/baselines/reference/ES5For-of36.types | 16 + tests/baselines/reference/ES5For-of7.symbols | 17 + tests/baselines/reference/ES5For-of7.types | 20 + tests/baselines/reference/ES5For-of8.symbols | 18 + tests/baselines/reference/ES5For-of8.types | 26 + .../reference/ES5For-ofTypeCheck10.symbols | 27 + .../reference/ES5For-ofTypeCheck10.types | 36 + .../reference/ES5For-ofTypeCheck11.symbols | 11 + .../reference/ES5For-ofTypeCheck11.types | 11 + .../reference/ES5For-ofTypeCheck12.symbols | 4 + .../reference/ES5For-ofTypeCheck12.types | 5 + .../reference/ES5For-ofTypeCheck7.symbols | 8 + .../reference/ES5For-ofTypeCheck7.types | 8 + .../reference/ES5For-ofTypeCheck8.symbols | 11 + .../reference/ES5For-ofTypeCheck8.types | 11 + .../reference/ES5For-ofTypeCheck9.symbols | 8 + .../reference/ES5For-ofTypeCheck9.types | 8 + .../reference/ES5SymbolProperty1.symbols | 26 + .../reference/ES5SymbolProperty1.types | 29 + .../reference/ES5SymbolProperty2.symbols | 23 + .../reference/ES5SymbolProperty2.types | 36 + .../reference/ES5SymbolProperty3.symbols | 15 + .../reference/ES5SymbolProperty3.types | 22 + .../reference/ES5SymbolProperty4.symbols | 20 + .../reference/ES5SymbolProperty4.types | 23 + .../reference/ES5SymbolProperty5.symbols | 20 + .../reference/ES5SymbolProperty5.types | 25 + .../reference/ES5SymbolProperty6.symbols | 10 + .../reference/ES5SymbolProperty6.types | 19 + .../reference/ES5SymbolProperty7.symbols | 20 + .../reference/ES5SymbolProperty7.types | 23 + .../reference/ExportAssignment7.symbols | 6 + .../reference/ExportAssignment7.types | 8 + .../reference/ExportAssignment8.symbols | 6 + .../reference/ExportAssignment8.types | 7 + ...AndModuleWithSameNameAndCommonRoot.symbols | 111 + ...onAndModuleWithSameNameAndCommonRoot.types | 125 + .../FunctionDeclaration10_es6.symbols | 5 + .../reference/FunctionDeclaration10_es6.types | 7 + .../FunctionDeclaration12_es6.symbols | 5 + .../reference/FunctionDeclaration12_es6.types | 7 + .../FunctionDeclaration13_es6.symbols | 9 + .../reference/FunctionDeclaration13_es6.types | 10 + .../reference/FunctionDeclaration3.symbols | 4 + .../reference/FunctionDeclaration3.types | 4 + .../FunctionDeclaration3_es6.symbols | 6 + .../reference/FunctionDeclaration3_es6.types | 6 + .../reference/FunctionDeclaration4.symbols | 7 + .../reference/FunctionDeclaration4.types | 7 + .../FunctionDeclaration5_es6.symbols | 4 + .../reference/FunctionDeclaration5_es6.types | 5 + .../reference/FunctionDeclaration6.symbols | 8 + .../reference/FunctionDeclaration6.types | 8 + .../FunctionDeclaration6_es6.symbols | 5 + .../reference/FunctionDeclaration6_es6.types | 6 + .../reference/FunctionDeclaration7.symbols | 7 + .../reference/FunctionDeclaration7.types | 7 + .../FunctionDeclaration7_es6.symbols | 10 + .../reference/FunctionDeclaration7_es6.types | 11 + .../FunctionDeclaration8_es6.symbols | 4 + .../reference/FunctionDeclaration8_es6.types | 7 + .../FunctionPropertyAssignments2_es6.symbols | 5 + .../FunctionPropertyAssignments2_es6.types | 6 + .../FunctionPropertyAssignments3_es6.symbols | 5 + .../FunctionPropertyAssignments3_es6.types | 6 + .../FunctionPropertyAssignments4_es6.symbols | 5 + .../FunctionPropertyAssignments4_es6.types | 6 + .../FunctionPropertyAssignments5_es6.symbols | 4 + .../FunctionPropertyAssignments5_es6.types | 7 + .../FunctionPropertyAssignments6_es6.symbols | 6 + .../FunctionPropertyAssignments6_es6.types | 7 + .../reference/InterfaceDeclaration8.symbols | 4 + .../reference/InterfaceDeclaration8.types | 4 + .../InvalidNonInstantiatedModule.symbols | 16 + .../InvalidNonInstantiatedModule.types | 18 + .../MemberAccessorDeclaration15.symbols | 8 + .../MemberAccessorDeclaration15.types | 8 + .../MemberFunctionDeclaration3_es6.symbols | 6 + .../MemberFunctionDeclaration3_es6.types | 7 + .../MemberFunctionDeclaration4_es6.symbols | 7 + .../MemberFunctionDeclaration4_es6.types | 7 + .../MemberFunctionDeclaration5_es6.symbols | 8 + .../MemberFunctionDeclaration5_es6.types | 8 + .../MemberFunctionDeclaration6_es6.symbols | 7 + .../MemberFunctionDeclaration6_es6.types | 7 + .../MemberFunctionDeclaration8_es6.symbols | 12 + .../MemberFunctionDeclaration8_es6.types | 19 + ...eAndClassWithSameNameAndCommonRoot.symbols | 64 + ...uleAndClassWithSameNameAndCommonRoot.types | 70 + ...dFunctionWithSameNameAndCommonRoot.symbols | 51 + ...AndFunctionWithSameNameAndCommonRoot.types | 63 + ...eWithExportedAndNonExportedClasses.symbols | 81 + ...uleWithExportedAndNonExportedClasses.types | 89 + ...uleWithExportedAndNonExportedEnums.symbols | 31 + ...oduleWithExportedAndNonExportedEnums.types | 35 + ...ithExportedAndNonExportedFunctions.symbols | 75 + ...eWithExportedAndNonExportedFunctions.types | 83 + ...hExportedAndNonExportedImportAlias.symbols | 109 + ...ithExportedAndNonExportedImportAlias.types | 120 + ...ithExportedAndNonExportedVariables.symbols | 26 + ...eWithExportedAndNonExportedVariables.types | 30 + ...nInitializedExportInInternalModule.symbols | 93 + ...NonInitializedExportInInternalModule.types | 107 + .../reference/ParameterList13.symbols | 7 + .../baselines/reference/ParameterList13.types | 7 + .../reference/ParameterList4.symbols | 5 + .../baselines/reference/ParameterList4.types | 5 + .../reference/ParameterList5.symbols | 5 + .../baselines/reference/ParameterList5.types | 6 + .../reference/ParameterList6.symbols | 9 + .../baselines/reference/ParameterList6.types | 9 + .../reference/ParameterList7.symbols | 13 + .../baselines/reference/ParameterList7.types | 13 + .../reference/ParameterList8.symbols | 13 + .../baselines/reference/ParameterList8.types | 13 + tests/baselines/reference/Protected1.symbols | 4 + tests/baselines/reference/Protected1.types | 4 + tests/baselines/reference/Protected2.symbols | 4 + tests/baselines/reference/Protected2.types | 4 + tests/baselines/reference/Protected4.symbols | 7 + tests/baselines/reference/Protected4.types | 7 + tests/baselines/reference/Protected6.symbols | 7 + tests/baselines/reference/Protected6.types | 7 + tests/baselines/reference/Protected7.symbols | 7 + tests/baselines/reference/Protected7.types | 7 + .../reference/TemplateExpression1.symbols | 4 + .../reference/TemplateExpression1.types | 6 + tests/baselines/reference/TupleType3.symbols | 4 + tests/baselines/reference/TupleType3.types | 4 + tests/baselines/reference/TupleType4.symbols | 4 + tests/baselines/reference/TupleType4.types | 4 + tests/baselines/reference/TupleType5.symbols | 4 + tests/baselines/reference/TupleType5.types | 4 + ...chWithExportedClassesOfTheSameName.symbols | 63 + ...EachWithExportedClassesOfTheSameName.types | 63 + ...WithExportedLocalVarsOfTheSameName.symbols | 66 + ...chWithExportedLocalVarsOfTheSameName.types | 76 + .../reference/TypeArgumentList1.symbols | 3 + .../reference/TypeArgumentList1.types | 18 + .../VariableDeclaration11_es6.symbols | 4 + .../reference/VariableDeclaration11_es6.types | 7 + .../VariableDeclaration13_es6.symbols | 7 + .../reference/VariableDeclaration13_es6.types | 10 + .../VariableDeclaration1_es6.symbols | 3 + .../reference/VariableDeclaration1_es6.types | 3 + .../VariableDeclaration2_es6.symbols | 4 + .../reference/VariableDeclaration2_es6.types | 4 + .../VariableDeclaration4_es6.symbols | 4 + .../reference/VariableDeclaration4_es6.types | 4 + .../VariableDeclaration6_es6.symbols | 3 + .../reference/VariableDeclaration6_es6.types | 4 + .../reference/YieldExpression10_es6.symbols | 9 + .../reference/YieldExpression10_es6.types | 13 + .../reference/YieldExpression11_es6.symbols | 10 + .../reference/YieldExpression11_es6.types | 13 + .../reference/YieldExpression12_es6.symbols | 8 + .../reference/YieldExpression12_es6.types | 10 + .../reference/YieldExpression14_es6.symbols | 10 + .../reference/YieldExpression14_es6.types | 12 + .../reference/YieldExpression15_es6.symbols | 6 + .../reference/YieldExpression15_es6.types | 9 + .../reference/YieldExpression16_es6.symbols | 11 + .../reference/YieldExpression16_es6.types | 12 + .../reference/YieldExpression17_es6.symbols | 5 + .../reference/YieldExpression17_es6.types | 8 + .../reference/YieldExpression18_es6.symbols | 4 + .../reference/YieldExpression18_es6.types | 9 + .../reference/YieldExpression1_es6.symbols | 3 + .../reference/YieldExpression1_es6.types | 4 + .../reference/YieldExpression2_es6.symbols | 3 + .../reference/YieldExpression2_es6.types | 5 + .../reference/YieldExpression5_es6.symbols | 6 + .../reference/YieldExpression5_es6.types | 9 + .../reference/YieldExpression6_es6.symbols | 7 + .../reference/YieldExpression6_es6.types | 8 + .../reference/YieldExpression8_es6.symbols | 10 + .../reference/YieldExpression8_es6.types | 14 + .../reference/YieldExpression9_es6.symbols | 6 + .../reference/YieldExpression9_es6.types | 10 + .../YieldStarExpression1_es6.symbols | 3 + .../reference/YieldStarExpression1_es6.types | 6 + .../YieldStarExpression2_es6.symbols | 3 + .../reference/YieldStarExpression2_es6.types | 6 + .../YieldStarExpression3_es6.symbols | 6 + .../reference/YieldStarExpression3_es6.types | 8 + ...bstractClassInLocalScopeIsAbstract.symbols | 17 + .../abstractClassInLocalScopeIsAbstract.types | 23 + .../abstractPropertyNegative.symbols | 107 + .../reference/abstractPropertyNegative.types | 115 + ...ssInstanceMemberFromStaticMethod01.symbols | 14 + ...cessInstanceMemberFromStaticMethod01.types | 15 + ...ssStaticMemberFromInstanceMethod01.symbols | 14 + ...cessStaticMemberFromInstanceMethod01.types | 15 + .../reference/accessibilityModifiers.symbols | 107 + .../reference/accessibilityModifiers.types | 114 + ...ssorParameterAccessibilityModifier.symbols | 12 + ...cessorParameterAccessibilityModifier.types | 12 + .../reference/accessorWithES3.symbols | 36 + .../baselines/reference/accessorWithES3.types | 40 + .../reference/accessorWithInitializer.symbols | 12 + .../reference/accessorWithInitializer.types | 14 + ...thMismatchedAccessibilityModifiers.symbols | 56 + ...WithMismatchedAccessibilityModifiers.types | 60 + .../reference/accessorWithRestParam.symbols | 12 + .../reference/accessorWithRestParam.types | 12 + .../reference/accessorWithoutBody1.symbols | 5 + .../reference/accessorWithoutBody1.types | 6 + .../reference/accessorWithoutBody2.symbols | 6 + .../reference/accessorWithoutBody2.types | 7 + .../accessorsAreNotContextuallyTyped.symbols | 30 + .../accessorsAreNotContextuallyTyped.types | 34 + .../baselines/reference/accessorsEmit.symbols | 30 + tests/baselines/reference/accessorsEmit.types | 34 + .../accessorsInAmbientContext.symbols | 40 + .../reference/accessorsInAmbientContext.types | 44 + .../accessorsNotAllowedInES3.symbols | 11 + .../reference/accessorsNotAllowedInES3.types | 14 + ...ssors_spec_section-4.5_error-cases.symbols | 34 + ...cessors_spec_section-4.5_error-cases.types | 42 + ...cessors_spec_section-4.5_inference.symbols | 64 + ...accessors_spec_section-4.5_inference.types | 70 + .../addMoreOverloadsToBaseSignature.symbols | 17 + .../addMoreOverloadsToBaseSignature.types | 17 + ...dditionOperatorWithInvalidOperands.symbols | 142 + .../additionOperatorWithInvalidOperands.types | 172 + ...torWithNullValueAndInvalidOperator.symbols | 65 + ...ratorWithNullValueAndInvalidOperator.types | 93 + ...peratorWithNullValueAndValidOperator.types | 40 +- ...rWithOnlyNullValueOrUndefinedValue.symbols | 18 + ...torWithOnlyNullValueOrUndefinedValue.types | 26 + .../additionOperatorWithTypeParameter.symbols | 139 + .../additionOperatorWithTypeParameter.types | 163 + ...thUndefinedValueAndInvalidOperands.symbols | 76 + ...WithUndefinedValueAndInvalidOperands.types | 93 + ...orWithUndefinedValueAndValidOperator.types | 40 +- .../reference/aliasAssignments.symbols | 26 + .../reference/aliasAssignments.types | 30 + tests/baselines/reference/aliasBug.symbols | 54 + tests/baselines/reference/aliasBug.types | 57 + tests/baselines/reference/aliasErrors.symbols | 85 + tests/baselines/reference/aliasErrors.types | 98 + .../reference/aliasInaccessibleModule.symbols | 11 + .../reference/aliasInaccessibleModule.types | 11 + .../aliasInaccessibleModule2.symbols | 20 + .../reference/aliasInaccessibleModule2.types | 20 + .../aliasOnMergedModuleInterface.symbols | 42 + .../aliasOnMergedModuleInterface.types | 49 + ...portAssignmentUsedInVarInitializer.symbols | 17 + ...ExportAssignmentUsedInVarInitializer.types | 20 + .../reference/aliasesInSystemModule1.symbols | 47 + .../reference/aliasesInSystemModule1.types | 57 + .../reference/aliasesInSystemModule2.symbols | 46 + .../reference/aliasesInSystemModule2.types | 56 + .../allowSyntheticDefaultImports10.symbols | 17 + .../allowSyntheticDefaultImports10.types | 29 + .../allowSyntheticDefaultImports3.symbols | 16 + .../allowSyntheticDefaultImports3.types | 19 + .../allowSyntheticDefaultImports6.symbols | 18 + .../allowSyntheticDefaultImports6.types | 19 + .../allowSyntheticDefaultImports8.symbols | 18 + .../allowSyntheticDefaultImports8.types | 24 + .../baselines/reference/alwaysStrict.symbols | 7 + tests/baselines/reference/alwaysStrict.types | 8 + .../reference/alwaysStrictES6.symbols | 7 + .../baselines/reference/alwaysStrictES6.types | 8 + .../reference/alwaysStrictModule.symbols | 11 + .../reference/alwaysStrictModule.types | 12 + .../reference/alwaysStrictModule2.symbols | 23 + .../reference/alwaysStrictModule2.types | 25 + .../alwaysStrictNoImplicitUseStrict.symbols | 11 + .../alwaysStrictNoImplicitUseStrict.types | 12 + .../ambientClassOverloadForFunction.symbols | 7 + .../ambientClassOverloadForFunction.types | 8 + ...larationsPatterns_tooManyAsterisks.symbols | 4 + ...eclarationsPatterns_tooManyAsterisks.types | 4 + .../baselines/reference/ambientEnum1.symbols | 17 + tests/baselines/reference/ambientEnum1.types | 19 + .../baselines/reference/ambientErrors.symbols | 109 + tests/baselines/reference/ambientErrors.types | 116 + .../reference/ambientErrors1.symbols | 4 + .../baselines/reference/ambientErrors1.types | 5 + .../ambientExportDefaultErrors.symbols | 33 + .../ambientExportDefaultErrors.types | 43 + ...ernalModuleInAnotherExternalModule.symbols | 20 + ...xternalModuleInAnotherExternalModule.types | 20 + ...ientExternalModuleInsideNonAmbient.symbols | 6 + ...mbientExternalModuleInsideNonAmbient.types | 6 + ...duleInsideNonAmbientExternalModule.symbols | 3 + ...ModuleInsideNonAmbientExternalModule.types | 3 + ...hRelativeExternalImportDeclaration.symbols | 24 + ...ithRelativeExternalImportDeclaration.types | 24 + ...ternalModuleWithRelativeModuleName.symbols | 10 + ...ExternalModuleWithRelativeModuleName.types | 10 + .../reference/ambientGetters.symbols | 14 + .../baselines/reference/ambientGetters.types | 15 + .../reference/ambientStatement1.symbols | 9 + .../reference/ambientStatement1.types | 12 + .../reference/ambientWithStatements.symbols | 40 + .../reference/ambientWithStatements.types | 52 + .../ambiguousGenericAssertion1.symbols | 30 + .../ambiguousGenericAssertion1.types | 39 + .../reference/ambiguousOverload.symbols | 47 + .../reference/ambiguousOverload.types | 59 + .../reference/amdDependencyComment1.symbols | 9 + .../reference/amdDependencyComment1.types | 12 + .../reference/amdDependencyComment2.symbols | 9 + .../reference/amdDependencyComment2.types | 12 + .../amdDependencyCommentName1.symbols | 9 + .../reference/amdDependencyCommentName1.types | 12 + .../amdDependencyCommentName2.symbols | 9 + .../reference/amdDependencyCommentName2.types | 12 + .../amdDependencyCommentName3.symbols | 11 + .../reference/amdDependencyCommentName3.types | 14 + .../amdDependencyCommentName4.symbols | 35 + .../reference/amdDependencyCommentName4.types | 35 + .../reference/amdModuleName2.symbols | 19 + .../baselines/reference/amdModuleName2.types | 21 + .../anonymousClassExpression2.symbols | 33 + .../reference/anonymousClassExpression2.types | 37 + .../reference/anonymousModules.symbols | 19 + .../reference/anonymousModules.types | 28 + .../reference/anyAsConstructor.symbols | 26 + .../reference/anyAsConstructor.types | 31 + .../anyAsGenericFunctionCall.symbols | 30 + .../reference/anyAsGenericFunctionCall.types | 35 + .../anyAssignabilityInInheritance.symbols | 34 +- tests/baselines/reference/anyDeclare.symbols | 14 + tests/baselines/reference/anyDeclare.types | 14 + .../reference/anyIdenticalToItself.symbols | 31 + .../reference/anyIdenticalToItself.types | 31 + .../anyIndexedAccessArrayNoException.symbols | 4 + .../anyIndexedAccessArrayNoException.types | 4 + .../reference/apparentTypeSubtyping.symbols | 48 + .../reference/apparentTypeSubtyping.types | 48 + .../reference/apparentTypeSupertype.symbols | 22 + .../reference/apparentTypeSupertype.types | 22 + ...argumentExpressionContextualTyping.symbols | 85 + .../argumentExpressionContextualTyping.types | 136 + ...tsBindsToFunctionScopeArgumentList.symbols | 11 + ...entsBindsToFunctionScopeArgumentList.types | 14 + .../argumentsObjectIterator01_ES5.symbols | 24 + .../argumentsObjectIterator01_ES5.types | 28 + .../argumentsObjectIterator02_ES5.symbols | 30 + .../argumentsObjectIterator02_ES5.types | 39 + .../argumentsObjectIterator03_ES5.symbols | 20 + .../argumentsObjectIterator03_ES5.types | 21 + .../reference/arithAssignTyping.symbols | 40 + .../reference/arithAssignTyping.types | 64 + .../arithmeticOnInvalidTypes.symbols | 29 + .../reference/arithmeticOnInvalidTypes.types | 33 + .../arithmeticOnInvalidTypes2.symbols | 34 + .../reference/arithmeticOnInvalidTypes2.types | 39 + ...thmeticOperatorWithInvalidOperands.symbols | 2680 + ...rithmeticOperatorWithInvalidOperands.types | 3160 + ...torWithNullValueAndInvalidOperands.symbols | 444 + ...ratorWithNullValueAndInvalidOperands.types | 744 + ...rWithOnlyNullValueOrUndefinedValue.symbols | 171 + ...torWithOnlyNullValueOrUndefinedValue.types | 251 + ...rithmeticOperatorWithTypeParameter.symbols | 573 + .../arithmeticOperatorWithTypeParameter.types | 683 + ...thUndefinedValueAndInvalidOperands.symbols | 564 + ...WithUndefinedValueAndInvalidOperands.types | 744 + .../arityAndOrderCompatibility01.symbols | 113 + .../arityAndOrderCompatibility01.types | 113 + .../reference/arrayAssignmentTest1.symbols | 233 + .../reference/arrayAssignmentTest1.types | 283 + .../reference/arrayAssignmentTest2.symbols | 153 + .../reference/arrayAssignmentTest2.types | 186 + .../reference/arrayAssignmentTest3.symbols | 25 + .../reference/arrayAssignmentTest3.types | 29 + .../reference/arrayAssignmentTest4.symbols | 39 + .../reference/arrayAssignmentTest4.types | 48 + .../reference/arrayAssignmentTest5.symbols | 109 + .../reference/arrayAssignmentTest5.types | 115 + tests/baselines/reference/arrayCast.symbols | 12 + tests/baselines/reference/arrayCast.types | 21 + ...ralAndArrayConstructorEquivalence1.symbols | 41 + ...teralAndArrayConstructorEquivalence1.types | 50 + ...yLiteralExpressionContextualTyping.symbols | 33 + ...rayLiteralExpressionContextualTyping.types | 71 + .../arrayLiteralTypeInference.symbols | 113 + .../reference/arrayLiteralTypeInference.types | 144 + .../baselines/reference/arrayLiterals.symbols | 94 + tests/baselines/reference/arrayLiterals.types | 153 + .../reference/arrayLiterals2ES6.symbols | 2 +- .../reference/arrayLiterals3.symbols | 68 + .../baselines/reference/arrayLiterals3.types | 101 + ...SubtypeIsAssignableToReadonlyArray.symbols | 77 + ...OfSubtypeIsAssignableToReadonlyArray.types | 85 + .../arrayReferenceWithoutTypeArgs.symbols | 9 + .../arrayReferenceWithoutTypeArgs.types | 9 + .../reference/arraySigChecking.symbols | 76 + .../reference/arraySigChecking.types | 96 + .../arrayTypeOfFunctionTypes.symbols | 49 + .../reference/arrayTypeOfFunctionTypes.types | 61 + .../arrayTypeOfFunctionTypes2.symbols | 49 + .../reference/arrayTypeOfFunctionTypes2.types | 61 + .../reference/arrayTypeOfTypeOf.symbols | 23 + .../reference/arrayTypeOfTypeOf.types | 28 + .../reference/arrowFunctionContexts.symbols | 198 + .../reference/arrowFunctionContexts.types | 263 + .../reference/arrowFunctionErrorSpan.symbols | 81 + .../reference/arrowFunctionErrorSpan.types | 105 + ...rrowFunctionInConstructorArgument1.symbols | 11 + .../arrowFunctionInConstructorArgument1.types | 14 + ...wFunctionMissingCurlyWithSemicolon.symbols | 14 + ...rowFunctionMissingCurlyWithSemicolon.types | 25 + .../arrowFunctionsMissingTokens.symbols | 135 + .../arrowFunctionsMissingTokens.types | 179 + tests/baselines/reference/asOperator2.symbols | 4 + tests/baselines/reference/asOperator2.types | 6 + .../reference/asOperatorAmbiguity.symbols | 26 + .../reference/asOperatorAmbiguity.types | 31 + .../asOperatorContextualType.symbols | 8 + .../reference/asOperatorContextualType.types | 11 + .../reference/asOperatorNames.symbols | 15 + .../baselines/reference/asOperatorNames.types | 19 + tests/baselines/reference/asiAbstract.symbols | 27 + tests/baselines/reference/asiAbstract.types | 29 + .../asiPreventsParsingAsInterface05.symbols | 16 + .../asiPreventsParsingAsInterface05.types | 19 + .../asiPublicPrivateProtected.symbols | 72 + .../reference/asiPublicPrivateProtected.types | 78 + tests/baselines/reference/asiReturn.symbols | 4 + tests/baselines/reference/asiReturn.types | 4 + .../assertInWrapSomeTypeParameter.symbols | 19 + .../assertInWrapSomeTypeParameter.types | 20 + .../reference/assignAnyToEveryType.symbols | 115 + .../reference/assignAnyToEveryType.types | 122 + .../assignFromBooleanInterface.symbols | 16 + .../assignFromBooleanInterface.types | 19 + .../assignFromBooleanInterface2.symbols | 51 + .../assignFromBooleanInterface2.types | 58 + .../assignFromNumberInterface.symbols | 16 + .../reference/assignFromNumberInterface.types | 19 + .../assignFromNumberInterface2.symbols | 70 + .../assignFromNumberInterface2.types | 77 + .../assignFromStringInterface.symbols | 16 + .../reference/assignFromStringInterface.types | 19 + .../assignFromStringInterface2.symbols | 174 + .../assignFromStringInterface2.types | 181 + ...gnLambdaToNominalSubtypeOfFunction.symbols | 24 + ...signLambdaToNominalSubtypeOfFunction.types | 30 + .../baselines/reference/assignToEnum.symbols | 30 + tests/baselines/reference/assignToEnum.types | 35 + .../reference/assignToExistingClass.symbols | 30 + .../reference/assignToExistingClass.types | 35 + tests/baselines/reference/assignToFn.symbols | 24 + tests/baselines/reference/assignToFn.types | 29 + .../reference/assignToInvalidLHS.symbols | 9 + .../reference/assignToInvalidLHS.types | 12 + .../reference/assignToModule.symbols | 7 + .../baselines/reference/assignToModule.types | 9 + .../assigningFromObjectToAnythingElse.symbols | 34 + .../assigningFromObjectToAnythingElse.types | 40 + .../reference/assignmentCompat1.symbols | 39 + .../reference/assignmentCompat1.types | 51 + ...signmentCompatBetweenTupleAndArray.symbols | 49 + ...assignmentCompatBetweenTupleAndArray.types | 56 + .../reference/assignmentCompatBug2.symbols | 109 + .../reference/assignmentCompatBug2.types | 155 + .../reference/assignmentCompatBug3.symbols | 61 + .../reference/assignmentCompatBug3.types | 72 + .../reference/assignmentCompatBug5.symbols | 31 + .../reference/assignmentCompatBug5.types | 42 + ...entCompatFunctionsWithOptionalArgs.symbols | 25 + ...nmentCompatFunctionsWithOptionalArgs.types | 39 + ...tInterfaceWithStringIndexSignature.symbols | 32 + ...patInterfaceWithStringIndexSignature.types | 34 + ...assignmentCompatWithCallSignatures.symbols | 128 + .../assignmentCompatWithCallSignatures.types | 168 + ...ssignmentCompatWithCallSignatures2.symbols | 160 + .../assignmentCompatWithCallSignatures2.types | 221 + ...ssignmentCompatWithCallSignatures4.symbols | 404 + .../assignmentCompatWithCallSignatures4.types | 428 + ...llSignaturesWithOptionalParameters.symbols | 309 + ...CallSignaturesWithOptionalParameters.types | 393 + ...thCallSignaturesWithRestParameters.symbols | 174 + ...WithCallSignaturesWithRestParameters.types | 258 + ...nmentCompatWithConstructSignatures.symbols | 102 + ...ignmentCompatWithConstructSignatures.types | 124 + ...mentCompatWithConstructSignatures2.symbols | 123 + ...gnmentCompatWithConstructSignatures2.types | 157 + ...mentCompatWithConstructSignatures4.symbols | 404 + ...gnmentCompatWithConstructSignatures4.types | 428 + ...ctSignaturesWithOptionalParameters.symbols | 237 + ...ructSignaturesWithOptionalParameters.types | 267 + ...llSignaturesWithOptionalParameters.symbols | 666 + ...CallSignaturesWithOptionalParameters.types | 801 + ...assignmentCompatWithNumericIndexer.symbols | 128 + .../assignmentCompatWithNumericIndexer.types | 138 + ...ssignmentCompatWithNumericIndexer2.symbols | 128 + .../assignmentCompatWithNumericIndexer2.types | 138 + ...ssignmentCompatWithNumericIndexer3.symbols | 114 + .../assignmentCompatWithNumericIndexer3.types | 122 + ...assignmentCompatWithObjectMembers4.symbols | 302 + .../assignmentCompatWithObjectMembers4.types | 348 + ...assignmentCompatWithObjectMembers5.symbols | 31 + .../assignmentCompatWithObjectMembers5.types | 33 + ...mpatWithObjectMembersAccessibility.symbols | 285 + ...CompatWithObjectMembersAccessibility.types | 329 + ...CompatWithObjectMembersOptionality.symbols | 242 + ...ntCompatWithObjectMembersOptionality.types | 272 + ...ompatWithObjectMembersOptionality2.symbols | 245 + ...tCompatWithObjectMembersOptionality2.types | 275 + ...ithObjectMembersStringNumericNames.symbols | 255 + ...tWithObjectMembersStringNumericNames.types | 302 + .../assignmentCompatWithOverloads.symbols | 64 + .../assignmentCompatWithOverloads.types | 72 + .../assignmentCompatWithStringIndexer.symbols | 156 + .../assignmentCompatWithStringIndexer.types | 168 + ...assignmentCompatWithStringIndexer2.symbols | 156 + .../assignmentCompatWithStringIndexer2.types | 168 + ...assignmentCompatWithStringIndexer3.symbols | 68 + .../assignmentCompatWithStringIndexer3.types | 73 + .../assignmentCompatability11.symbols | 39 + .../reference/assignmentCompatability11.types | 44 + .../assignmentCompatability12.symbols | 39 + .../reference/assignmentCompatability12.types | 44 + .../assignmentCompatability13.symbols | 39 + .../reference/assignmentCompatability13.types | 44 + .../assignmentCompatability14.symbols | 39 + .../reference/assignmentCompatability14.types | 44 + .../assignmentCompatability15.symbols | 39 + .../reference/assignmentCompatability15.types | 44 + .../assignmentCompatability16.symbols | 39 + .../reference/assignmentCompatability16.types | 46 + .../assignmentCompatability17.symbols | 39 + .../reference/assignmentCompatability17.types | 46 + .../assignmentCompatability18.symbols | 39 + .../reference/assignmentCompatability18.types | 45 + .../assignmentCompatability19.symbols | 39 + .../reference/assignmentCompatability19.types | 45 + .../assignmentCompatability20.symbols | 39 + .../reference/assignmentCompatability20.types | 45 + .../assignmentCompatability21.symbols | 39 + .../reference/assignmentCompatability21.types | 45 + .../assignmentCompatability22.symbols | 39 + .../reference/assignmentCompatability22.types | 45 + .../assignmentCompatability23.symbols | 39 + .../reference/assignmentCompatability23.types | 45 + .../assignmentCompatability24.symbols | 43 + .../reference/assignmentCompatability24.types | 47 + .../assignmentCompatability25.symbols | 39 + .../reference/assignmentCompatability25.types | 42 + .../assignmentCompatability26.symbols | 39 + .../reference/assignmentCompatability26.types | 42 + .../assignmentCompatability27.symbols | 39 + .../reference/assignmentCompatability27.types | 42 + .../assignmentCompatability28.symbols | 39 + .../reference/assignmentCompatability28.types | 42 + .../assignmentCompatability29.symbols | 39 + .../reference/assignmentCompatability29.types | 42 + .../assignmentCompatability30.symbols | 39 + .../reference/assignmentCompatability30.types | 42 + .../assignmentCompatability31.symbols | 39 + .../reference/assignmentCompatability31.types | 42 + .../assignmentCompatability32.symbols | 39 + .../reference/assignmentCompatability32.types | 42 + .../assignmentCompatability33.symbols | 42 + .../reference/assignmentCompatability33.types | 45 + .../assignmentCompatability34.symbols | 42 + .../reference/assignmentCompatability34.types | 45 + .../assignmentCompatability35.symbols | 39 + .../reference/assignmentCompatability35.types | 42 + .../assignmentCompatability37.symbols | 41 + .../reference/assignmentCompatability37.types | 44 + .../assignmentCompatability38.symbols | 41 + .../reference/assignmentCompatability38.types | 44 + .../assignmentCompatability39.symbols | 46 + .../reference/assignmentCompatability39.types | 52 + .../assignmentCompatability40.symbols | 43 + .../reference/assignmentCompatability40.types | 48 + .../assignmentCompatability41.symbols | 46 + .../reference/assignmentCompatability41.types | 52 + .../assignmentCompatability42.symbols | 46 + .../reference/assignmentCompatability42.types | 52 + .../assignmentCompatability43.symbols | 48 + .../reference/assignmentCompatability43.types | 54 + ...y-member-off-of-function-interface.symbols | 60 + ...ply-member-off-of-function-interface.types | 81 + ...l-member-off-of-function-interface.symbols | 60 + ...all-member-off-of-function-interface.types | 81 + .../reference/assignmentLHSIsValue.symbols | 165 + .../reference/assignmentLHSIsValue.types | 245 + ...mentRestElementWithErrorSourceType.symbols | 5 + ...gnmentRestElementWithErrorSourceType.types | 11 + .../reference/assignmentToFunction.symbols | 20 + .../reference/assignmentToFunction.types | 25 + .../reference/assignmentToObject.symbols | 14 + .../reference/assignmentToObject.types | 16 + .../assignmentToObjectAndFunction.symbols | 69 + .../assignmentToObjectAndFunction.types | 76 + ...signmentToParenthesizedExpression1.symbols | 7 + ...assignmentToParenthesizedExpression1.types | 12 + ...signmentToParenthesizedIdentifiers.symbols | 210 + ...assignmentToParenthesizedIdentifiers.types | 325 + .../assignmentToReferenceTypes.symbols | 39 + .../assignmentToReferenceTypes.types | 53 + tests/baselines/reference/assignments.symbols | 57 + tests/baselines/reference/assignments.types | 76 + .../asyncAliasReturnType_es5.symbols | 2 +- .../asyncArrowFunction10_es2017.symbols | 10 + .../asyncArrowFunction10_es2017.types | 12 + .../asyncArrowFunction10_es5.symbols | 10 + .../reference/asyncArrowFunction10_es5.types | 12 + .../asyncArrowFunction10_es6.symbols | 10 + .../reference/asyncArrowFunction10_es6.types | 12 + .../asyncArrowFunction3_es2017.symbols | 6 + .../asyncArrowFunction3_es2017.types | 6 + .../reference/asyncArrowFunction3_es5.symbols | 6 + .../reference/asyncArrowFunction3_es5.types | 6 + .../reference/asyncArrowFunction3_es6.symbols | 6 + .../reference/asyncArrowFunction3_es6.types | 6 + .../asyncArrowFunction5_es2017.symbols | 5 + .../asyncArrowFunction5_es2017.types | 10 + .../reference/asyncArrowFunction5_es5.symbols | 5 + .../reference/asyncArrowFunction5_es5.types | 10 + .../reference/asyncArrowFunction5_es6.symbols | 5 + .../reference/asyncArrowFunction5_es6.types | 10 + .../asyncArrowFunction6_es2017.symbols | 6 + .../asyncArrowFunction6_es2017.types | 9 + .../reference/asyncArrowFunction6_es5.symbols | 6 + .../reference/asyncArrowFunction6_es5.types | 9 + .../reference/asyncArrowFunction6_es6.symbols | 6 + .../reference/asyncArrowFunction6_es6.types | 9 + .../asyncArrowFunction7_es2017.symbols | 12 + .../asyncArrowFunction7_es2017.types | 16 + .../reference/asyncArrowFunction7_es5.symbols | 12 + .../reference/asyncArrowFunction7_es5.types | 16 + .../reference/asyncArrowFunction7_es6.symbols | 12 + .../reference/asyncArrowFunction7_es6.types | 16 + .../asyncArrowFunction8_es2017.symbols | 9 + .../asyncArrowFunction8_es2017.types | 13 + .../reference/asyncArrowFunction8_es5.symbols | 9 + .../reference/asyncArrowFunction8_es5.types | 13 + .../reference/asyncArrowFunction8_es6.symbols | 9 + .../reference/asyncArrowFunction8_es6.types | 13 + .../asyncArrowFunction9_es2017.symbols | 7 + .../asyncArrowFunction9_es2017.types | 14 + .../reference/asyncArrowFunction9_es5.symbols | 7 + .../reference/asyncArrowFunction9_es5.types | 14 + .../reference/asyncArrowFunction9_es6.symbols | 7 + .../reference/asyncArrowFunction9_es6.types | 14 + ...ArrowFunctionCapturesArguments_es5.symbols | 20 + ...ncArrowFunctionCapturesArguments_es5.types | 23 + .../asyncAwaitIsolatedModules_es2017.symbols | 111 + .../asyncAwaitIsolatedModules_es2017.types | 122 + .../asyncAwaitIsolatedModules_es5.symbols | 111 + .../asyncAwaitIsolatedModules_es5.types | 122 + .../asyncAwaitIsolatedModules_es6.symbols | 111 + .../asyncAwaitIsolatedModules_es6.types | 122 + .../reference/asyncClass_es5.symbols | 4 + .../baselines/reference/asyncClass_es5.types | 4 + .../reference/asyncClass_es6.symbols | 4 + .../baselines/reference/asyncClass_es6.types | 4 + .../reference/asyncConstructor_es5.symbols | 7 + .../reference/asyncConstructor_es5.types | 7 + .../reference/asyncConstructor_es6.symbols | 7 + .../reference/asyncConstructor_es6.types | 7 + .../reference/asyncDeclare_es5.symbols | 5 + .../reference/asyncDeclare_es5.types | 5 + .../reference/asyncDeclare_es6.symbols | 5 + .../reference/asyncDeclare_es6.types | 5 + .../baselines/reference/asyncEnum_es5.symbols | 7 + tests/baselines/reference/asyncEnum_es5.types | 7 + .../baselines/reference/asyncEnum_es6.symbols | 7 + tests/baselines/reference/asyncEnum_es6.types | 7 + .../asyncFunctionDeclaration10_es2017.symbols | 6 + .../asyncFunctionDeclaration10_es2017.types | 14 + .../asyncFunctionDeclaration10_es5.symbols | 6 + .../asyncFunctionDeclaration10_es5.types | 14 + .../asyncFunctionDeclaration10_es6.symbols | 6 + .../asyncFunctionDeclaration10_es6.types | 14 + .../asyncFunctionDeclaration12_es2017.symbols | 6 + .../asyncFunctionDeclaration12_es2017.types | 8 + .../asyncFunctionDeclaration12_es5.symbols | 6 + .../asyncFunctionDeclaration12_es5.types | 8 + .../asyncFunctionDeclaration12_es6.symbols | 6 + .../asyncFunctionDeclaration12_es6.types | 8 + .../asyncFunctionDeclaration13_es2017.symbols | 10 + .../asyncFunctionDeclaration13_es2017.types | 11 + .../asyncFunctionDeclaration13_es5.symbols | 10 + .../asyncFunctionDeclaration13_es5.types | 11 + .../asyncFunctionDeclaration13_es6.symbols | 10 + .../asyncFunctionDeclaration13_es6.types | 11 + .../asyncFunctionDeclaration15_es5.symbols | 83 + .../asyncFunctionDeclaration15_es5.types | 93 + .../asyncFunctionDeclaration15_es6.symbols | 83 + .../asyncFunctionDeclaration15_es6.types | 93 + .../asyncFunctionDeclaration3_es2017.symbols | 6 + .../asyncFunctionDeclaration3_es2017.types | 6 + .../asyncFunctionDeclaration3_es5.symbols | 6 + .../asyncFunctionDeclaration3_es5.types | 6 + .../asyncFunctionDeclaration3_es6.symbols | 6 + .../asyncFunctionDeclaration3_es6.types | 6 + .../asyncFunctionDeclaration5_es2017.symbols | 5 + .../asyncFunctionDeclaration5_es2017.types | 11 + .../asyncFunctionDeclaration5_es5.symbols | 5 + .../asyncFunctionDeclaration5_es5.types | 11 + .../asyncFunctionDeclaration5_es6.symbols | 5 + .../asyncFunctionDeclaration5_es6.types | 11 + .../asyncFunctionDeclaration6_es2017.symbols | 6 + .../asyncFunctionDeclaration6_es2017.types | 8 + .../asyncFunctionDeclaration6_es5.symbols | 6 + .../asyncFunctionDeclaration6_es5.types | 8 + .../asyncFunctionDeclaration6_es6.symbols | 6 + .../asyncFunctionDeclaration6_es6.types | 8 + .../asyncFunctionDeclaration7_es2017.symbols | 12 + .../asyncFunctionDeclaration7_es2017.types | 14 + .../asyncFunctionDeclaration7_es5.symbols | 12 + .../asyncFunctionDeclaration7_es5.types | 14 + .../asyncFunctionDeclaration7_es6.symbols | 12 + .../asyncFunctionDeclaration7_es6.types | 14 + .../asyncFunctionDeclaration8_es2017.symbols | 4 + .../asyncFunctionDeclaration8_es2017.types | 7 + .../asyncFunctionDeclaration8_es5.symbols | 4 + .../asyncFunctionDeclaration8_es5.types | 7 + .../asyncFunctionDeclaration8_es6.symbols | 4 + .../asyncFunctionDeclaration8_es6.types | 7 + .../asyncFunctionDeclaration9_es2017.symbols | 9 + .../asyncFunctionDeclaration9_es2017.types | 12 + .../asyncFunctionDeclaration9_es5.symbols | 9 + .../asyncFunctionDeclaration9_es5.types | 12 + .../asyncFunctionDeclaration9_es6.symbols | 9 + .../asyncFunctionDeclaration9_es6.types | 12 + ...onDeclarationCapturesArguments_es5.symbols | 22 + ...tionDeclarationCapturesArguments_es5.types | 25 + .../asyncFunctionNoReturnType.symbols | 7 + .../reference/asyncFunctionNoReturnType.types | 10 + .../reference/asyncGetter_es5.symbols | 8 + .../baselines/reference/asyncGetter_es5.types | 8 + .../reference/asyncGetter_es6.symbols | 8 + .../baselines/reference/asyncGetter_es6.types | 8 + .../asyncImportedPromise_es6.symbols | 20 + .../reference/asyncImportedPromise_es6.types | 20 + .../reference/asyncInterface_es5.symbols | 4 + .../reference/asyncInterface_es5.types | 4 + .../reference/asyncInterface_es6.symbols | 4 + .../reference/asyncInterface_es6.types | 4 + .../reference/asyncModule_es5.symbols | 4 + .../baselines/reference/asyncModule_es5.types | 4 + .../reference/asyncModule_es6.symbols | 4 + .../baselines/reference/asyncModule_es6.types | 4 + .../asyncQualifiedReturnType_es6.symbols | 17 + .../asyncQualifiedReturnType_es6.types | 17 + .../reference/asyncSetter_es5.symbols | 9 + .../baselines/reference/asyncSetter_es5.types | 9 + .../reference/asyncSetter_es6.symbols | 9 + .../baselines/reference/asyncSetter_es6.types | 9 + .../reference/augmentExportEquals1.symbols | 27 + .../reference/augmentExportEquals1.types | 30 + .../reference/augmentExportEquals1_1.symbols | 30 + .../reference/augmentExportEquals1_1.types | 32 + .../reference/augmentExportEquals2.symbols | 26 + .../reference/augmentExportEquals2.types | 28 + .../reference/augmentExportEquals2_1.symbols | 29 + .../reference/augmentExportEquals2_1.types | 31 + .../reference/augmentExportEquals7.symbols | 19 + .../reference/augmentExportEquals7.types | 19 + ...ClassWithPrototypePropertyOnModule.symbols | 13 + ...edClassWithPrototypePropertyOnModule.types | 13 + ...TypeAssignmentCompatIndexSignature.symbols | 51 + ...edTypeAssignmentCompatIndexSignature.types | 53 + .../reference/augmentedTypesClass.symbols | 18 + .../reference/augmentedTypesClass.types | 19 + .../reference/augmentedTypesClass2.symbols | 48 + .../reference/augmentedTypesClass2.types | 51 + .../reference/augmentedTypesClass2a.symbols | 12 + .../reference/augmentedTypesClass2a.types | 13 + .../reference/augmentedTypesClass4.symbols | 10 + .../reference/augmentedTypesClass4.types | 10 + .../reference/augmentedTypesEnum.symbols | 77 + .../reference/augmentedTypesEnum.types | 81 + .../reference/augmentedTypesEnum2.symbols | 32 + .../reference/augmentedTypesEnum2.types | 33 + .../reference/augmentedTypesEnum3.symbols | 41 + .../reference/augmentedTypesEnum3.types | 41 + .../reference/augmentedTypesFunction.symbols | 75 + .../reference/augmentedTypesFunction.types | 79 + .../reference/augmentedTypesInterface.symbols | 55 + .../reference/augmentedTypesInterface.types | 56 + .../reference/augmentedTypesModules.symbols | 224 + .../reference/augmentedTypesModules.types | 243 + .../reference/augmentedTypesModules2.symbols | 64 + .../reference/augmentedTypesModules2.types | 68 + .../reference/augmentedTypesModules3.symbols | 16 + .../reference/augmentedTypesModules3.types | 17 + .../reference/augmentedTypesVar.symbols | 68 + .../reference/augmentedTypesVar.types | 81 + tests/baselines/reference/autoLift2.symbols | 52 + tests/baselines/reference/autoLift2.types | 82 + tests/baselines/reference/autolift3.symbols | 52 + tests/baselines/reference/autolift3.types | 69 + tests/baselines/reference/autolift4.symbols | 77 + tests/baselines/reference/autolift4.types | 93 + .../reference/awaitLiteralValues.symbols | 38 + .../reference/awaitLiteralValues.types | 49 + .../await_unaryExpression_es2017_1.symbols | 9 +- .../await_unaryExpression_es2017_1.types | 1 - .../await_unaryExpression_es2017_2.symbols | 5 +- .../await_unaryExpression_es2017_2.types | 1 - .../await_unaryExpression_es2017_3.symbols | 32 + .../await_unaryExpression_es2017_3.types | 46 + .../await_unaryExpression_es6_1.symbols | 9 +- .../await_unaryExpression_es6_1.types | 1 - .../await_unaryExpression_es6_2.symbols | 5 +- .../await_unaryExpression_es6_2.types | 1 - .../await_unaryExpression_es6_3.symbols | 32 + .../await_unaryExpression_es6_3.types | 46 + .../baselines/reference/badArrayIndex.symbols | 4 + tests/baselines/reference/badArrayIndex.types | 6 + .../reference/badArraySyntax.symbols | 35 + .../baselines/reference/badArraySyntax.types | 48 + .../badExternalModuleReference.symbols | 18 + .../badExternalModuleReference.types | 18 + tests/baselines/reference/baseCheck.symbols | 75 + tests/baselines/reference/baseCheck.types | 96 + .../baseConstraintOfDecorator.symbols | 29 + .../reference/baseConstraintOfDecorator.types | 34 + .../baseExpressionTypeParameters.symbols | 32 + .../baseExpressionTypeParameters.types | 35 + .../baseTypePrivateMemberClash.symbols | 19 + .../baseTypePrivateMemberClash.types | 19 + tests/baselines/reference/bases.symbols | 35 + tests/baselines/reference/bases.types | 47 + .../reference/binaryArithmatic3.symbols | 6 + .../reference/binaryArithmatic3.types | 7 + .../reference/binaryArithmatic4.symbols | 4 + .../reference/binaryArithmatic4.types | 7 + .../binaryIntegerLiteralError.symbols | 16 + .../reference/binaryIntegerLiteralError.types | 27 + tests/baselines/reference/bind1.symbols | 9 + tests/baselines/reference/bind1.types | 10 + .../bindingPatternInParameter01.symbols | 17 + .../bindingPatternInParameter01.types | 32 + ...bitwiseCompoundAssignmentOperators.symbols | 98 + .../bitwiseCompoundAssignmentOperators.types | 136 + ...itwiseNotOperatorInvalidOperations.symbols | 18 + .../bitwiseNotOperatorInvalidOperations.types | 28 + ...bitwiseNotOperatorWithAnyOtherType.symbols | 188 + .../bitwiseNotOperatorWithAnyOtherType.types | 249 + .../blockScopedBindingUsedBeforeDef.symbols | 16 + .../blockScopedBindingUsedBeforeDef.types | 21 + ...edFunctionDeclarationInStrictClass.symbols | 17 + ...opedFunctionDeclarationInStrictClass.types | 22 + ...dFunctionDeclarationInStrictModule.symbols | 10 + ...pedFunctionDeclarationInStrictModule.types | 15 + ...ScopedFunctionDeclarationStrictES5.symbols | 10 + ...ckScopedFunctionDeclarationStrictES5.types | 18 + ...ScopedFunctionDeclarationStrictES6.symbols | 10 + ...ckScopedFunctionDeclarationStrictES6.types | 18 + ...opedSameNameFunctionDeclarationES5.symbols | 39 + ...ScopedSameNameFunctionDeclarationES5.types | 53 + ...opedSameNameFunctionDeclarationES6.symbols | 39 + ...ScopedSameNameFunctionDeclarationES6.types | 53 + ...meNameFunctionDeclarationStrictES5.symbols | 40 + ...SameNameFunctionDeclarationStrictES5.types | 56 + ...meNameFunctionDeclarationStrictES6.symbols | 40 + ...SameNameFunctionDeclarationStrictES6.types | 56 + .../blockScopedVariablesUseBeforeDef.symbols | 214 + .../blockScopedVariablesUseBeforeDef.types | 226 + .../reference/bluebirdStaticThis.symbols | 1170 + .../reference/bluebirdStaticThis.types | 1184 + .../reference/boolInsteadOfBoolean.symbols | 12 + .../reference/boolInsteadOfBoolean.types | 14 + .../reference/booleanAssignment.symbols | 31 + .../reference/booleanAssignment.types | 43 + ...breakInIterationOrSwitchStatement4.symbols | 6 + .../breakInIterationOrSwitchStatement4.types | 7 + ...akNotInIterationOrSwitchStatement1.symbols | 3 + ...reakNotInIterationOrSwitchStatement1.types | 3 + ...akNotInIterationOrSwitchStatement2.symbols | 8 + ...reakNotInIterationOrSwitchStatement2.types | 10 + .../baselines/reference/breakTarget5.symbols | 11 + tests/baselines/reference/breakTarget5.types | 18 + .../baselines/reference/breakTarget6.symbols | 5 + tests/baselines/reference/breakTarget6.types | 7 + .../reference/cachedModuleResolution6.symbols | 8 + .../reference/cachedModuleResolution6.types | 8 + .../reference/cachedModuleResolution7.symbols | 8 + .../reference/cachedModuleResolution7.types | 8 + .../reference/cachedModuleResolution8.symbols | 8 + .../reference/cachedModuleResolution8.types | 8 + .../reference/cachedModuleResolution9.symbols | 9 + .../reference/cachedModuleResolution9.types | 9 + .../reference/callConstructAssignment.symbols | 15 + .../reference/callConstructAssignment.types | 17 + ...ExpressionWithMissingTypeArgument1.symbols | 3 + ...llExpressionWithMissingTypeArgument1.types | 8 + ...WithIncorrectNumberOfTypeArguments.symbols | 172 + ...onWithIncorrectNumberOfTypeArguments.types | 227 + ...onGenericFunctionWithTypeArguments.symbols | 108 + ...lNonGenericFunctionWithTypeArguments.types | 133 + tests/baselines/reference/callOnClass.symbols | 9 + tests/baselines/reference/callOnClass.types | 10 + .../reference/callOnInstance.symbols | 23 + .../baselines/reference/callOnInstance.types | 32 + ...OverloadViaElementAccessExpression.symbols | 34 + ...llOverloadViaElementAccessExpression.types | 42 + .../reference/callOverloads1.symbols | 39 + .../baselines/reference/callOverloads1.types | 43 + .../reference/callOverloads2.symbols | 49 + .../baselines/reference/callOverloads2.types | 53 + .../reference/callOverloads3.symbols | 36 + .../baselines/reference/callOverloads3.types | 46 + .../reference/callOverloads4.symbols | 38 + .../baselines/reference/callOverloads4.types | 48 + .../reference/callOverloads5.symbols | 45 + .../baselines/reference/callOverloads5.types | 56 + ...ignatureAssignabilityInInheritance.symbols | 151 + ...lSignatureAssignabilityInInheritance.types | 151 + ...gnatureAssignabilityInInheritance3.symbols | 396 + ...SignatureAssignabilityInInheritance3.types | 396 + ...ithOptionalParameterAndInitializer.symbols | 164 + ...eWithOptionalParameterAndInitializer.types | 219 + ...ouldBeResolvedBeforeSpecialization.symbols | 27 + ...ShouldBeResolvedBeforeSpecialization.types | 31 + ...naturesThatDifferOnlyByReturnType2.symbols | 36 + ...ignaturesThatDifferOnlyByReturnType2.types | 40 + ...AccessibilityModifiersOnParameters.symbols | 150 + ...thAccessibilityModifiersOnParameters.types | 161 + ...lSignaturesWithDuplicateParameters.symbols | 150 + ...allSignaturesWithDuplicateParameters.types | 161 + ...ignaturesWithParameterInitializers.symbols | 166 + ...lSignaturesWithParameterInitializers.types | 221 + ...gnaturesWithParameterInitializers2.symbols | 66 + ...SignaturesWithParameterInitializers2.types | 82 + .../reference/callWithSpread2.symbols | 128 + .../baselines/reference/callWithSpread2.types | 179 + ...callWithWrongNumberOfTypeArguments.symbols | 15 + .../callWithWrongNumberOfTypeArguments.types | 18 + .../callbackArgsDifferByOptionality.symbols | 18 + .../callbackArgsDifferByOptionality.types | 20 + .../cannotInvokeNewOnErrorExpression.symbols | 11 + .../cannotInvokeNewOnErrorExpression.types | 15 + .../cannotInvokeNewOnIndexExpression.symbols | 4 + .../cannotInvokeNewOnIndexExpression.types | 8 + ...reSuperPropertyAccessInSuperCall01.symbols | 23 + ...tureSuperPropertyAccessInSuperCall01.types | 27 + .../reference/capturedLetConstInLoop5.types | 162 +- .../capturedLetConstInLoop5_ES6.symbols | 515 +- .../capturedLetConstInLoop5_ES6.types | 163 +- .../reference/capturedLetConstInLoop6.types | 170 +- .../capturedLetConstInLoop6_ES6.types | 170 +- .../reference/capturedLetConstInLoop7.types | 202 +- .../capturedLetConstInLoop7_ES6.types | 202 +- .../reference/capturedLetConstInLoop8.types | 88 +- .../capturedLetConstInLoop8_ES6.types | 88 +- .../capturedParametersInInitializers2.symbols | 20 + .../capturedParametersInInitializers2.types | 24 + tests/baselines/reference/castOfYield.symbols | 9 + tests/baselines/reference/castOfYield.types | 18 + .../reference/castParentheses.symbols | 14 +- .../baselines/reference/castingTuple.symbols | 132 + tests/baselines/reference/castingTuple.types | 168 + .../catchClauseWithInitializer1.symbols | 6 + .../catchClauseWithInitializer1.types | 7 + .../catchClauseWithTypeAnnotation.symbols | 5 + .../catchClauseWithTypeAnnotation.types | 5 + tests/baselines/reference/cf.symbols | 111 + tests/baselines/reference/cf.types | 169 + .../reference/chainedAssignment1.symbols | 55 + .../reference/chainedAssignment1.types | 63 + .../reference/chainedAssignment3.symbols | 59 + .../reference/chainedAssignment3.types | 77 + .../chainedAssignmentChecking.symbols | 51 + .../reference/chainedAssignmentChecking.types | 58 + ...terConstrainedToOtherTypeParameter.symbols | 65 + ...meterConstrainedToOtherTypeParameter.types | 83 + ...erConstrainedToOtherTypeParameter2.symbols | 197 + ...eterConstrainedToOtherTypeParameter2.types | 257 + ...straintOfJavascriptClassExpression.symbols | 32 +- ...onstraintOfJavascriptClassExpression.types | 37 +- .../baselines/reference/checkJsFiles.symbols | 7 + tests/baselines/reference/checkJsFiles.types | 10 + .../baselines/reference/checkJsFiles2.symbols | 8 + tests/baselines/reference/checkJsFiles2.types | 11 + .../baselines/reference/checkJsFiles3.symbols | 8 + tests/baselines/reference/checkJsFiles3.types | 11 + .../baselines/reference/checkJsFiles4.symbols | 8 + tests/baselines/reference/checkJsFiles4.types | 11 + .../checkJsFiles_noErrorLocation.symbols | 39 + .../checkJsFiles_noErrorLocation.types | 46 + .../reference/checkJsdocTypeTag2.symbols | 51 + .../reference/checkJsdocTypeTag2.types | 76 + ...checkJsdocTypeTagOnObjectProperty2.symbols | 51 + .../checkJsdocTypeTagOnObjectProperty2.types | 67 + .../checkJsxChildrenProperty13.symbols | 68 + .../checkJsxChildrenProperty13.types | 73 + .../checkJsxChildrenProperty2.symbols | 144 + .../reference/checkJsxChildrenProperty2.types | 170 + .../checkJsxChildrenProperty4.symbols | 110 + .../reference/checkJsxChildrenProperty4.types | 132 + .../checkJsxChildrenProperty5.symbols | 82 + .../reference/checkJsxChildrenProperty5.types | 92 + .../checkJsxChildrenProperty7.symbols | 90 + .../reference/checkJsxChildrenProperty7.types | 106 + ...checkSuperCallBeforeThisAccessing2.symbols | 30 + .../checkSuperCallBeforeThisAccessing2.types | 35 + ...checkSuperCallBeforeThisAccessing5.symbols | 20 + .../checkSuperCallBeforeThisAccessing5.types | 21 + ...checkSuperCallBeforeThisAccessing8.symbols | 21 + .../checkSuperCallBeforeThisAccessing8.types | 22 + ...ypePredicateForRedundantProperties.symbols | 11 + ...kTypePredicateForRedundantProperties.types | 12 + .../reference/circularImportAlias.symbols | 47 + .../reference/circularImportAlias.types | 48 + .../circularIndexedAccessErrors.symbols | 94 + .../circularIndexedAccessErrors.types | 94 + .../reference/circularModuleImports.symbols | 16 + .../reference/circularModuleImports.types | 16 + .../reference/circularReference.symbols | 104 + .../reference/circularReference.types | 127 + .../circularTypeofWithVarOrFunc.symbols | 29 + .../circularTypeofWithVarOrFunc.types | 31 + tests/baselines/reference/class2.symbols | 5 + tests/baselines/reference/class2.types | 6 + .../reference/classAbstractAccessor.symbols | 19 + .../reference/classAbstractAccessor.types | 20 + ...ctAssignabilityConstructorFunction.symbols | 17 + ...ractAssignabilityConstructorFunction.types | 20 + ...ssAbstractClinterfaceAssignability.symbols | 52 + ...lassAbstractClinterfaceAssignability.types | 54 + .../classAbstractConstructor.symbols | 6 + .../reference/classAbstractConstructor.types | 6 + ...ssAbstractConstructorAssignability.symbols | 36 + ...lassAbstractConstructorAssignability.types | 39 + .../classAbstractCrashedOnce.symbols | 23 + .../reference/classAbstractCrashedOnce.types | 26 + .../classAbstractDeclarations.d.symbols | 49 + .../classAbstractDeclarations.d.types | 49 + .../reference/classAbstractExtends.symbols | 31 + .../reference/classAbstractExtends.types | 31 + .../classAbstractFactoryFunction.symbols | 42 + .../classAbstractFactoryFunction.types | 48 + .../reference/classAbstractGeneric.symbols | 77 + .../reference/classAbstractGeneric.types | 77 + .../classAbstractImportInstantiation.symbols | 19 + .../classAbstractImportInstantiation.types | 21 + .../reference/classAbstractInAModule.symbols | 22 + .../reference/classAbstractInAModule.types | 24 + .../classAbstractInheritance.symbols | 43 + .../reference/classAbstractInheritance.types | 43 + .../classAbstractInstantiations1.symbols | 52 + .../classAbstractInstantiations1.types | 63 + .../classAbstractInstantiations2.symbols | 118 + .../classAbstractInstantiations2.types | 126 + .../classAbstractManyKeywords.symbols | 14 + .../reference/classAbstractManyKeywords.types | 15 + .../classAbstractMergedDeclaration.symbols | 91 + .../classAbstractMergedDeclaration.types | 101 + ...ssAbstractMethodInNonAbstractClass.symbols | 14 + ...lassAbstractMethodInNonAbstractClass.types | 14 + ...ssAbstractMethodWithImplementation.symbols | 7 + ...lassAbstractMethodWithImplementation.types | 7 + .../classAbstractMixedWithModifiers.symbols | 31 + .../classAbstractMixedWithModifiers.types | 31 + .../reference/classAbstractOverloads.symbols | 56 + .../reference/classAbstractOverloads.types | 56 + .../classAbstractOverrideWithAbstract.symbols | 48 + .../classAbstractOverrideWithAbstract.types | 48 + .../reference/classAbstractProperties.symbols | 31 + .../reference/classAbstractProperties.types | 31 + .../classAbstractSingleLineDecl.symbols | 22 + .../classAbstractSingleLineDecl.types | 28 + .../reference/classAbstractSuperCalls.symbols | 74 + .../reference/classAbstractSuperCalls.types | 82 + .../classAbstractUsingAbstractMethod1.symbols | 42 + .../classAbstractUsingAbstractMethod1.types | 48 + ...classAbstractUsingAbstractMethods2.symbols | 54 + .../classAbstractUsingAbstractMethods2.types | 54 + .../classAbstractWithInterface.symbols | 4 + .../classAbstractWithInterface.types | 4 + ...ndInterfaceMergeConflictingMembers.symbols | 42 + ...sAndInterfaceMergeConflictingMembers.types | 42 + .../classAndVariableWithSameName.symbols | 21 + .../classAndVariableWithSameName.types | 23 + .../reference/classBodyWithStatements.symbols | 28 + .../reference/classBodyWithStatements.types | 33 + .../reference/classCannotExtendVar.symbols | 11 + .../reference/classCannotExtendVar.types | 11 + .../classConstructorAccessibility.symbols | 77 + .../classConstructorAccessibility.types | 89 + .../classConstructorAccessibility2.symbols | 128 + .../classConstructorAccessibility2.types | 169 + .../classConstructorAccessibility3.symbols | 80 + .../classConstructorAccessibility3.types | 89 + .../classConstructorAccessibility5.symbols | 23 + .../classConstructorAccessibility5.types | 25 + ...sConstructorOverloadsAccessibility.symbols | 59 + ...assConstructorOverloadsAccessibility.types | 59 + ...ConstructorParametersAccessibility.symbols | 66 + ...ssConstructorParametersAccessibility.types | 67 + ...onstructorParametersAccessibility2.symbols | 66 + ...sConstructorParametersAccessibility2.types | 67 + ...ssExpressionExtendingAbstractClass.symbols | 15 + ...lassExpressionExtendingAbstractClass.types | 16 + .../classExpressionWithDecorator1.symbols | 6 + .../classExpressionWithDecorator1.types | 9 + .../classExtendingClassLikeType.symbols | 154 + .../classExtendingClassLikeType.types | 182 + .../classExtendingNonConstructor.symbols | 34 + .../classExtendingNonConstructor.types | 43 + .../reference/classExtendingPrimitive.symbols | 39 + .../reference/classExtendingPrimitive.types | 48 + .../classExtendingPrimitive2.symbols | 9 + .../reference/classExtendingPrimitive2.types | 12 + .../classExtendingQualifiedName.symbols | 13 + .../classExtendingQualifiedName.types | 15 + ...edWithModuleNotReferingConstructor.symbols | 28 + ...rgedWithModuleNotReferingConstructor.types | 29 + ...ClauseClassNotReferringConstructor.symbols | 17 + ...dsClauseClassNotReferringConstructor.types | 18 + .../classExtendsEveryObjectType.symbols | 41 + .../classExtendsEveryObjectType.types | 45 + .../classExtendsEveryObjectType2.symbols | 8 + .../classExtendsEveryObjectType2.types | 11 + .../reference/classExtendsInterface.symbols | 28 + .../reference/classExtendsInterface.types | 28 + .../classExtendsInterfaceInExpression.symbols | 16 + .../classExtendsInterfaceInExpression.types | 19 + .../classExtendsInterfaceInModule.symbols | 44 + .../classExtendsInterfaceInModule.types | 44 + ...rfaceThatExtendsClassWithPrivates1.symbols | 39 + ...terfaceThatExtendsClassWithPrivates1.types | 41 + .../reference/classExtendsItself.symbols | 16 + .../reference/classExtendsItself.types | 16 + .../classExtendsItselfIndirectly.symbols | 40 + .../classExtendsItselfIndirectly.types | 40 + .../classExtendsItselfIndirectly2.symbols | 68 + .../classExtendsItselfIndirectly2.types | 68 + .../classExtendsItselfIndirectly3.symbols | 45 + .../classExtendsItselfIndirectly3.types | 45 + .../classExtendsMultipleBaseClasses.symbols | 12 + .../classExtendsMultipleBaseClasses.types | 12 + .../reference/classExtendsNull.symbols | 23 + .../reference/classExtendsNull.types | 32 + ...ExtendsShadowedConstructorFunction.symbols | 19 + ...ssExtendsShadowedConstructorFunction.types | 20 + ...assExtendsValidConstructorFunction.symbols | 12 + ...classExtendsValidConstructorFunction.types | 13 + ...classHeritageWithTrailingSeparator.symbols | 9 + .../classHeritageWithTrailingSeparator.types | 9 + .../reference/classImplementsClass2.symbols | 36 + .../reference/classImplementsClass2.types | 40 + .../reference/classImplementsClass4.symbols | 41 + .../reference/classImplementsClass4.types | 46 + .../reference/classImplementsClass5.symbols | 44 + .../reference/classImplementsClass5.types | 50 + .../reference/classImplementsClass6.symbols | 49 + .../reference/classImplementsClass6.types | 60 + ...lassImplementsMergedClassInterface.symbols | 46 + .../classImplementsMergedClassInterface.types | 46 + .../baselines/reference/classIndexer2.symbols | 16 + tests/baselines/reference/classIndexer2.types | 16 + .../baselines/reference/classIndexer3.symbols | 21 + tests/baselines/reference/classIndexer3.types | 21 + .../baselines/reference/classIndexer4.symbols | 21 + tests/baselines/reference/classIndexer4.types | 21 + .../reference/classInheritence.symbols | 9 + .../reference/classInheritence.types | 9 + .../classIsSubtypeOfBaseType.symbols | 36 + .../reference/classIsSubtypeOfBaseType.types | 36 + .../classMemberInitializerScoping.symbols | 51 + .../classMemberInitializerScoping.types | 59 + ...sMemberInitializerWithLamdaScoping.symbols | 83 + ...assMemberInitializerWithLamdaScoping.types | 92 + ...MemberInitializerWithLamdaScoping2.symbols | 31 + ...ssMemberInitializerWithLamdaScoping2.types | 34 + ...MemberInitializerWithLamdaScoping3.symbols | 31 + ...ssMemberInitializerWithLamdaScoping3.types | 34 + ...MemberInitializerWithLamdaScoping4.symbols | 29 + ...ssMemberInitializerWithLamdaScoping4.types | 32 + .../classMemberWithMissingIdentifier.symbols | 7 + .../classMemberWithMissingIdentifier.types | 8 + .../classMemberWithMissingIdentifier2.symbols | 8 + .../classMemberWithMissingIdentifier2.types | 11 + tests/baselines/reference/classOrder2.symbols | 32 + tests/baselines/reference/classOrder2.types | 35 + .../classOverloadForFunction.symbols | 7 + .../reference/classOverloadForFunction.types | 7 + .../classOverloadForFunction2.symbols | 7 + .../reference/classOverloadForFunction2.types | 7 + .../reference/classPropertyAsPrivate.symbols | 76 + .../reference/classPropertyAsPrivate.types | 85 + .../classPropertyAsProtected.symbols | 76 + .../reference/classPropertyAsProtected.types | 85 + .../classPropertyIsPublicByDefault.symbols | 75 + .../classPropertyIsPublicByDefault.types | 84 + .../reference/classSideInheritance1.symbols | 41 + .../reference/classSideInheritance1.types | 51 + .../reference/classSideInheritance2.symbols | 45 + .../reference/classSideInheritance2.types | 47 + .../reference/classSideInheritance3.symbols | 50 + .../reference/classSideInheritance3.types | 52 + .../classTypeParametersInStatics.symbols | 110 + .../classTypeParametersInStatics.types | 128 + .../reference/classUpdateTests.symbols | 206 + .../reference/classUpdateTests.types | 232 + ...classWithBaseClassButNoConstructor.symbols | 107 + .../classWithBaseClassButNoConstructor.types | 119 + .../reference/classWithConstructors.symbols | 132 + .../reference/classWithConstructors.types | 159 + .../classWithDuplicateIdentifier.symbols | 29 + .../classWithDuplicateIdentifier.types | 31 + .../classWithEmptyTypeParameter.symbols | 4 + .../classWithEmptyTypeParameter.types | 4 + .../classWithMultipleBaseClasses.symbols | 47 + .../classWithMultipleBaseClasses.types | 47 + ...hOverloadImplementationOfWrongName.symbols | 15 + ...ithOverloadImplementationOfWrongName.types | 15 + ...OverloadImplementationOfWrongName2.symbols | 15 + ...thOverloadImplementationOfWrongName2.types | 15 + .../classWithPredefinedTypesAsNames.symbols | 15 + .../classWithPredefinedTypesAsNames.types | 15 + .../classWithPredefinedTypesAsNames2.symbols | 5 + .../classWithPredefinedTypesAsNames2.types | 7 + .../classWithPrivateProperty.symbols | 83 + .../reference/classWithPrivateProperty.types | 96 + .../reference/classWithStaticMembers.symbols | 67 + .../reference/classWithStaticMembers.types | 70 + ...classWithTwoConstructorDefinitions.symbols | 23 + .../classWithTwoConstructorDefinitions.types | 23 + .../classWithoutExplicitConstructor.symbols | 40 + .../classWithoutExplicitConstructor.types | 50 + .../reference/cloduleSplitAcrossFiles.symbols | 16 + .../reference/cloduleSplitAcrossFiles.types | 17 + .../reference/cloduleStaticMembers.symbols | 32 + .../reference/cloduleStaticMembers.types | 36 + .../baselines/reference/cloduleTest2.symbols | 115 + tests/baselines/reference/cloduleTest2.types | 138 + .../cloduleWithDuplicateMember1.symbols | 31 + .../cloduleWithDuplicateMember1.types | 34 + .../cloduleWithDuplicateMember2.symbols | 25 + .../cloduleWithDuplicateMember2.types | 26 + ...cloduleWithPriorInstantiatedModule.symbols | 27 + .../cloduleWithPriorInstantiatedModule.types | 28 + .../reference/clodulesDerivedClasses.symbols | 41 + .../reference/clodulesDerivedClasses.types | 43 + .../collisionArgumentsArrowFunctions.symbols | 38 + .../collisionArgumentsArrowFunctions.types | 47 + ...collisionArgumentsClassConstructor.symbols | 186 + .../collisionArgumentsClassConstructor.types | 192 + .../collisionArgumentsClassMethod.symbols | 143 + .../collisionArgumentsClassMethod.types | 147 + .../collisionArgumentsFunction.symbols | 134 + .../collisionArgumentsFunction.types | 138 + ...lisionArgumentsFunctionExpressions.symbols | 94 + ...ollisionArgumentsFunctionExpressions.types | 98 + ...nCodeGenModuleWithAccessorChildren.symbols | 105 + ...ionCodeGenModuleWithAccessorChildren.types | 111 + .../collisionExportsRequireAndAlias.symbols | 32 + .../collisionExportsRequireAndAlias.types | 34 + .../collisionExportsRequireAndClass.symbols | 55 + .../collisionExportsRequireAndClass.types | 55 + .../collisionExportsRequireAndEnum.symbols | 127 + .../collisionExportsRequireAndEnum.types | 127 + ...collisionExportsRequireAndFunction.symbols | 39 + .../collisionExportsRequireAndFunction.types | 45 + ...portsRequireAndInternalModuleAlias.symbols | 63 + ...ExportsRequireAndInternalModuleAlias.types | 69 + .../collisionExportsRequireAndModule.symbols | 154 + .../collisionExportsRequireAndModule.types | 156 + .../collisionExportsRequireAndVar.symbols | 54 + .../collisionExportsRequireAndVar.types | 66 + ...onSuperAndLocalFunctionInAccessors.symbols | 74 + ...sionSuperAndLocalFunctionInAccessors.types | 79 + ...SuperAndLocalFunctionInConstructor.symbols | 43 + ...onSuperAndLocalFunctionInConstructor.types | 46 + ...isionSuperAndLocalFunctionInMethod.symbols | 52 + ...llisionSuperAndLocalFunctionInMethod.types | 53 + ...ionSuperAndLocalFunctionInProperty.symbols | 35 + ...isionSuperAndLocalFunctionInProperty.types | 39 + ...llisionSuperAndLocalVarInAccessors.symbols | 70 + ...collisionSuperAndLocalVarInAccessors.types | 82 + ...isionSuperAndLocalVarInConstructor.symbols | 40 + ...llisionSuperAndLocalVarInConstructor.types | 47 + .../collisionSuperAndLocalVarInMethod.symbols | 40 + .../collisionSuperAndLocalVarInMethod.types | 45 + ...ollisionSuperAndLocalVarInProperty.symbols | 37 + .../collisionSuperAndLocalVarInProperty.types | 46 + .../collisionSuperAndNameResolution.symbols | 28 + .../collisionSuperAndNameResolution.types | 30 + .../collisionSuperAndParameter.symbols | 150 + .../collisionSuperAndParameter.types | 164 + .../collisionSuperAndParameter1.symbols | 18 + .../collisionSuperAndParameter1.types | 19 + ...dPropertyNameAsConstuctorParameter.symbols | 64 + ...AndPropertyNameAsConstuctorParameter.types | 68 + ...sionThisExpressionAndAliasInGlobal.symbols | 14 + ...lisionThisExpressionAndAliasInGlobal.types | 17 + ...sExpressionAndAmbientClassInGlobal.symbols | 11 + ...hisExpressionAndAmbientClassInGlobal.types | 14 + ...hisExpressionAndAmbientVarInGlobal.symbols | 10 + ...nThisExpressionAndAmbientVarInGlobal.types | 14 + ...sionThisExpressionAndClassInGlobal.symbols | 7 + ...lisionThisExpressionAndClassInGlobal.types | 9 + ...isionThisExpressionAndEnumInGlobal.symbols | 13 + ...llisionThisExpressionAndEnumInGlobal.types | 15 + ...nThisExpressionAndFunctionInGlobal.symbols | 9 + ...ionThisExpressionAndFunctionInGlobal.types | 12 + ...isExpressionAndLocalVarInAccessors.symbols | 94 + ...ThisExpressionAndLocalVarInAccessors.types | 116 + ...ExpressionAndLocalVarInConstructor.symbols | 44 + ...isExpressionAndLocalVarInConstructor.types | 54 + ...hisExpressionAndLocalVarInFunction.symbols | 20 + ...nThisExpressionAndLocalVarInFunction.types | 26 + ...nThisExpressionAndLocalVarInLambda.symbols | 28 + ...ionThisExpressionAndLocalVarInLambda.types | 38 + ...nThisExpressionAndLocalVarInMethod.symbols | 39 + ...ionThisExpressionAndLocalVarInMethod.types | 51 + ...hisExpressionAndLocalVarInProperty.symbols | 41 + ...nThisExpressionAndLocalVarInProperty.types | 51 + ...sionAndLocalVarWithSuperExperssion.symbols | 45 + ...essionAndLocalVarWithSuperExperssion.types | 51 + ...ionThisExpressionAndModuleInGlobal.symbols | 11 + ...isionThisExpressionAndModuleInGlobal.types | 13 + ...ionThisExpressionAndNameResolution.symbols | 31 + ...isionThisExpressionAndNameResolution.types | 35 + ...ollisionThisExpressionAndParameter.symbols | 224 + .../collisionThisExpressionAndParameter.types | 254 + ...dPropertyNameAsConstuctorParameter.symbols | 76 + ...AndPropertyNameAsConstuctorParameter.types | 84 + ...lisionThisExpressionAndVarInGlobal.symbols | 7 + ...ollisionThisExpressionAndVarInGlobal.types | 10 + ...commaOperatorInvalidAssignmentType.symbols | 50 + .../commaOperatorInvalidAssignmentType.types | 68 + .../commaOperatorLeftSideUnused.symbols | 153 + .../commaOperatorLeftSideUnused.types | 337 + ...commaOperatorOtherInvalidOperation.symbols | 36 + .../commaOperatorOtherInvalidOperation.types | 42 + .../commaOperatorWithoutOperand.symbols | 52 + .../commaOperatorWithoutOperand.types | 87 + .../reference/commentOnClassAccessor1.symbols | 10 + .../reference/commentOnClassAccessor1.types | 11 + .../reference/commentOnClassAccessor2.symbols | 17 + .../reference/commentOnClassAccessor2.types | 18 + .../commentOnImportStatement1.symbols | 6 + .../reference/commentOnImportStatement1.types | 6 + .../commentOnImportStatement2.symbols | 5 + .../reference/commentOnImportStatement2.types | 5 + .../commentOnImportStatement3.symbols | 7 + .../reference/commentOnImportStatement3.types | 7 + .../commentsOnObjectLiteral1.symbols | 10 + .../reference/commentsOnObjectLiteral1.types | 13 + .../commentsOnObjectLiteral2.symbols | 19 + .../reference/commentsOnObjectLiteral2.types | 28 + .../reference/commonSourceDir2.symbols | 8 + .../reference/commonSourceDir2.types | 8 + .../reference/commonSourceDir4.symbols | 8 + .../reference/commonSourceDir4.types | 8 + ...RelationshipObjectsOnCallSignature.symbols | 676 + ...NoRelationshipObjectsOnCallSignature.types | 788 + ...nshipObjectsOnConstructorSignature.symbols | 672 + ...ionshipObjectsOnConstructorSignature.types | 784 + ...elationshipObjectsOnIndexSignature.symbols | 389 + ...oRelationshipObjectsOnIndexSignature.types | 453 + ...ationshipObjectsOnOptionalProperty.symbols | 111 + ...elationshipObjectsOnOptionalProperty.types | 127 + ...ithNoRelationshipObjectsOnProperty.symbols | 213 + ...rWithNoRelationshipObjectsOnProperty.types | 245 + ...torWithNoRelationshipPrimitiveType.symbols | 831 + ...ratorWithNoRelationshipPrimitiveType.types | 991 + ...torWithNoRelationshipTypeParameter.symbols | 647 + ...ratorWithNoRelationshipTypeParameter.types | 767 + ...omparisonOperatorWithTypeParameter.symbols | 342 + .../comparisonOperatorWithTypeParameter.types | 406 + .../complexClassRelationships.symbols | 117 + .../reference/complexClassRelationships.types | 123 + .../complexRecursiveCollections.symbols | 3806 + .../complexRecursiveCollections.types | 3806 + ...GenericRecursiveBaseClassReference.symbols | 17 + ...edGenericRecursiveBaseClassReference.types | 24 + .../reference/complicatedPrivacy.symbols | 196 + .../reference/complicatedPrivacy.types | 204 + ...ndAdditionAssignmentLHSCanBeAssigned.types | 8 +- ...itionAssignmentLHSCannotBeAssigned.symbols | 40 + ...dditionAssignmentLHSCannotBeAssigned.types | 50 + ...itionAssignmentWithInvalidOperands.symbols | 123 + ...dditionAssignmentWithInvalidOperands.types | 166 + ...meticAssignmentWithInvalidOperands.symbols | 189 + ...thmeticAssignmentWithInvalidOperands.types | 259 + .../compoundAssignmentLHSIsValue.symbols | 313 + .../compoundAssignmentLHSIsValue.types | 472 + ...ationAssignmentLHSCannotBeAssigned.symbols | 189 + ...tiationAssignmentLHSCannotBeAssigned.types | 259 + ...ExponentiationAssignmentLHSIsValue.symbols | 184 + ...ndExponentiationAssignmentLHSIsValue.types | 264 + ...computedPropertiesInDestructuring1.symbols | 111 + .../computedPropertiesInDestructuring1.types | 186 + ...utedPropertiesInDestructuring1_ES6.symbols | 113 + ...mputedPropertiesInDestructuring1_ES6.types | 190 + .../computedPropertyNames12_ES5.symbols | 46 + .../computedPropertyNames12_ES5.types | 58 + .../computedPropertyNames12_ES6.symbols | 46 + .../computedPropertyNames12_ES6.types | 58 + .../computedPropertyNames14_ES5.symbols | 18 + .../computedPropertyNames14_ES5.types | 25 + .../computedPropertyNames14_ES6.symbols | 18 + .../computedPropertyNames14_ES6.types | 25 + .../computedPropertyNames15_ES5.symbols | 22 + .../computedPropertyNames15_ES5.types | 22 + .../computedPropertyNames15_ES6.symbols | 22 + .../computedPropertyNames15_ES6.types | 22 + .../computedPropertyNames17_ES5.symbols | 23 + .../computedPropertyNames17_ES5.types | 31 + .../computedPropertyNames17_ES6.symbols | 23 + .../computedPropertyNames17_ES6.types | 31 + .../computedPropertyNames19_ES5.symbols | 10 + .../computedPropertyNames19_ES5.types | 15 + .../computedPropertyNames19_ES6.symbols | 10 + .../computedPropertyNames19_ES6.types | 15 + .../computedPropertyNames21_ES5.symbols | 11 + .../computedPropertyNames21_ES5.types | 16 + .../computedPropertyNames21_ES6.symbols | 11 + .../computedPropertyNames21_ES6.types | 16 + .../computedPropertyNames23_ES5.symbols | 13 + .../computedPropertyNames23_ES5.types | 23 + .../computedPropertyNames23_ES6.symbols | 13 + .../computedPropertyNames23_ES6.types | 23 + .../computedPropertyNames24_ES5.symbols | 16 + .../computedPropertyNames24_ES5.types | 21 + .../computedPropertyNames24_ES6.symbols | 18 + .../computedPropertyNames24_ES6.types | 23 + .../computedPropertyNames26_ES5.symbols | 18 + .../computedPropertyNames26_ES5.types | 28 + .../computedPropertyNames26_ES6.symbols | 20 + .../computedPropertyNames26_ES6.types | 30 + .../computedPropertyNames27_ES5.symbols | 10 + .../computedPropertyNames27_ES5.types | 15 + .../computedPropertyNames27_ES6.symbols | 10 + .../computedPropertyNames27_ES6.types | 15 + .../computedPropertyNames2_ES5.symbols | 30 + .../computedPropertyNames2_ES5.types | 32 + .../computedPropertyNames2_ES6.symbols | 30 + .../computedPropertyNames2_ES6.types | 32 + .../computedPropertyNames30_ES5.symbols | 24 + .../computedPropertyNames30_ES5.types | 34 + .../computedPropertyNames30_ES6.symbols | 24 + .../computedPropertyNames30_ES6.types | 34 + .../computedPropertyNames32_ES5.symbols | 17 + .../computedPropertyNames32_ES5.types | 21 + .../computedPropertyNames32_ES6.symbols | 17 + .../computedPropertyNames32_ES6.types | 21 + .../computedPropertyNames34_ES5.symbols | 22 + .../computedPropertyNames34_ES5.types | 27 + .../computedPropertyNames34_ES6.symbols | 22 + .../computedPropertyNames34_ES6.types | 27 + .../computedPropertyNames35_ES5.symbols | 15 + .../computedPropertyNames35_ES5.types | 18 + .../computedPropertyNames35_ES6.symbols | 15 + .../computedPropertyNames35_ES6.types | 18 + .../computedPropertyNames36_ES5.symbols | 27 + .../computedPropertyNames36_ES5.types | 28 + .../computedPropertyNames36_ES6.symbols | 27 + .../computedPropertyNames36_ES6.types | 28 + .../computedPropertyNames38_ES5.symbols | 25 + .../computedPropertyNames38_ES5.types | 32 + .../computedPropertyNames38_ES6.symbols | 25 + .../computedPropertyNames38_ES6.types | 32 + .../computedPropertyNames39_ES5.symbols | 25 + .../computedPropertyNames39_ES5.types | 32 + .../computedPropertyNames39_ES6.symbols | 25 + .../computedPropertyNames39_ES6.types | 32 + .../computedPropertyNames3_ES5.symbols | 22 + .../computedPropertyNames3_ES5.types | 37 + .../computedPropertyNames3_ES6.symbols | 22 + .../computedPropertyNames3_ES6.types | 37 + .../computedPropertyNames40_ES5.symbols | 26 + .../computedPropertyNames40_ES5.types | 28 + .../computedPropertyNames40_ES6.symbols | 26 + .../computedPropertyNames40_ES6.types | 28 + .../computedPropertyNames42_ES5.symbols | 22 + .../computedPropertyNames42_ES5.types | 22 + .../computedPropertyNames42_ES6.symbols | 22 + .../computedPropertyNames42_ES6.types | 22 + .../computedPropertyNames43_ES5.symbols | 32 + .../computedPropertyNames43_ES5.types | 33 + .../computedPropertyNames43_ES6.symbols | 32 + .../computedPropertyNames43_ES6.types | 33 + .../computedPropertyNames44_ES5.symbols | 31 + .../computedPropertyNames44_ES5.types | 32 + .../computedPropertyNames44_ES6.symbols | 31 + .../computedPropertyNames44_ES6.types | 32 + .../computedPropertyNames45_ES5.symbols | 32 + .../computedPropertyNames45_ES5.types | 33 + .../computedPropertyNames45_ES6.symbols | 32 + .../computedPropertyNames45_ES6.types | 33 + .../computedPropertyNames49_ES5.symbols | 34 + .../computedPropertyNames49_ES5.types | 65 + .../computedPropertyNames49_ES6.symbols | 34 + .../computedPropertyNames49_ES6.types | 65 + .../computedPropertyNames50_ES5.symbols | 34 + .../computedPropertyNames50_ES5.types | 65 + .../computedPropertyNames50_ES6.symbols | 34 + .../computedPropertyNames50_ES6.types | 65 + .../computedPropertyNames51_ES5.symbols | 27 + .../computedPropertyNames51_ES5.types | 30 + .../computedPropertyNames51_ES6.symbols | 27 + .../computedPropertyNames51_ES6.types | 30 + .../computedPropertyNames5_ES5.symbols | 19 + .../computedPropertyNames5_ES5.types | 32 + .../computedPropertyNames5_ES6.symbols | 19 + .../computedPropertyNames5_ES6.types | 32 + .../computedPropertyNames6_ES5.symbols | 22 + .../computedPropertyNames6_ES5.types | 26 + .../computedPropertyNames6_ES6.symbols | 22 + .../computedPropertyNames6_ES6.types | 26 + .../computedPropertyNames8_ES5.symbols | 25 + .../computedPropertyNames8_ES5.types | 28 + .../computedPropertyNames8_ES6.symbols | 25 + .../computedPropertyNames8_ES6.types | 28 + .../computedPropertyNames9_ES5.symbols | 32 + .../computedPropertyNames9_ES5.types | 42 + .../computedPropertyNames9_ES6.symbols | 32 + .../computedPropertyNames9_ES6.types | 42 + ...dPropertyNamesContextualType10_ES5.symbols | 15 + ...tedPropertyNamesContextualType10_ES5.types | 23 + ...dPropertyNamesContextualType10_ES6.symbols | 15 + ...tedPropertyNamesContextualType10_ES6.types | 23 + ...edPropertyNamesContextualType8_ES5.symbols | 18 + ...utedPropertyNamesContextualType8_ES5.types | 28 + ...edPropertyNamesContextualType8_ES6.symbols | 18 + ...utedPropertyNamesContextualType8_ES6.types | 28 + ...edPropertyNamesContextualType9_ES5.symbols | 18 + ...utedPropertyNamesContextualType9_ES5.types | 26 + ...edPropertyNamesContextualType9_ES6.symbols | 18 + ...utedPropertyNamesContextualType9_ES6.types | 26 + ...dPropertyNamesDeclarationEmit3_ES5.symbols | 6 + ...tedPropertyNamesDeclarationEmit3_ES5.types | 9 + ...dPropertyNamesDeclarationEmit3_ES6.symbols | 6 + ...tedPropertyNamesDeclarationEmit3_ES6.types | 9 + ...dPropertyNamesDeclarationEmit4_ES5.symbols | 6 + ...tedPropertyNamesDeclarationEmit4_ES5.types | 9 + ...dPropertyNamesDeclarationEmit4_ES6.symbols | 6 + ...tedPropertyNamesDeclarationEmit4_ES6.types | 9 + ...mputedPropertyNamesOnOverloads_ES5.symbols | 21 + ...computedPropertyNamesOnOverloads_ES5.types | 23 + ...mputedPropertyNamesOnOverloads_ES6.symbols | 21 + ...computedPropertyNamesOnOverloads_ES6.types | 23 + .../reference/concatClassAndString.symbols | 8 + .../reference/concatClassAndString.types | 10 + .../reference/conditionalExpression1.symbols | 4 + .../reference/conditionalExpression1.types | 9 + .../conditionalExpressionNewLine1.symbols | 4 + .../conditionalExpressionNewLine1.types | 8 + .../conditionalExpressionNewLine10.symbols | 10 + .../conditionalExpressionNewLine10.types | 26 + .../conditionalExpressionNewLine2.symbols | 5 + .../conditionalExpressionNewLine2.types | 10 + .../conditionalExpressionNewLine3.symbols | 5 + .../conditionalExpressionNewLine3.types | 10 + .../conditionalExpressionNewLine4.symbols | 5 + .../conditionalExpressionNewLine4.types | 10 + .../conditionalExpressionNewLine5.symbols | 5 + .../conditionalExpressionNewLine5.types | 10 + .../conditionalExpressionNewLine6.symbols | 6 + .../conditionalExpressionNewLine6.types | 12 + .../conditionalExpressionNewLine7.symbols | 6 + .../conditionalExpressionNewLine7.types | 12 + .../conditionalExpressionNewLine8.symbols | 6 + .../conditionalExpressionNewLine8.types | 18 + .../conditionalExpressionNewLine9.symbols | 8 + .../conditionalExpressionNewLine9.types | 22 + ...itionalOperatorWithoutIdenticalBCT.symbols | 112 + ...nditionalOperatorWithoutIdenticalBCT.types | 138 + .../conflictMarkerDiff3Trivia1.symbols | 14 + .../conflictMarkerDiff3Trivia1.types | 15 + .../conflictMarkerDiff3Trivia2.symbols | 22 + .../conflictMarkerDiff3Trivia2.types | 24 + .../reference/conflictMarkerTrivia1.symbols | 12 + .../reference/conflictMarkerTrivia1.types | 13 + .../reference/conflictMarkerTrivia2.symbols | 19 + .../reference/conflictMarkerTrivia2.types | 21 + .../reference/conflictMarkerTrivia3.symbols | 6 + .../reference/conflictMarkerTrivia3.types | 9 + .../reference/conflictMarkerTrivia4.symbols | 5 + .../reference/conflictMarkerTrivia4.types | 9 + .../conflictingMemberTypesInBases.symbols | 30 + .../conflictingMemberTypesInBases.types | 30 + .../conflictingTypeAnnotatedVar.symbols | 10 + .../conflictingTypeAnnotatedVar.types | 10 + ...eclarationShadowedByVarDeclaration.symbols | 32 + ...tDeclarationShadowedByVarDeclaration.types | 40 + .../constDeclarations-access.symbols | 8 + .../reference/constDeclarations-access.types | 10 + .../constDeclarations-access2.symbols | 89 + .../reference/constDeclarations-access2.types | 128 + .../constDeclarations-access3.symbols | 147 + .../reference/constDeclarations-access3.types | 189 + .../constDeclarations-access4.symbols | 147 + .../reference/constDeclarations-access4.types | 188 + .../constDeclarations-access5.symbols | 151 + .../reference/constDeclarations-access5.types | 193 + .../constDeclarations-ambient-errors.symbols | 22 + .../constDeclarations-ambient-errors.types | 29 + .../constDeclarations-errors.symbols | 34 + .../reference/constDeclarations-errors.types | 44 + .../constDeclarations-invalidContexts.symbols | 53 + .../constDeclarations-invalidContexts.types | 81 + .../constDeclarations-scopes.symbols | 291 + .../reference/constDeclarations-scopes.types | 372 + ...stDeclarations-useBeforeDefinition.symbols | 19 + ...onstDeclarations-useBeforeDefinition.types | 21 + ...tDeclarations-useBeforeDefinition2.symbols | 8 + ...nstDeclarations-useBeforeDefinition2.types | 9 + .../constDeclarations-validContexts.symbols | 195 + .../constDeclarations-validContexts.types | 251 + tests/baselines/reference/constEnum2.symbols | 39 + tests/baselines/reference/constEnum2.types | 57 + .../constEnumBadPropertyNames.symbols | 9 + .../reference/constEnumBadPropertyNames.types | 11 + .../reference/constEnumErrors.symbols | 107 + .../baselines/reference/constEnumErrors.types | 130 + .../constEnumPropertyAccess2.symbols | 53 + .../reference/constEnumPropertyAccess2.types | 63 + .../reference/constraintErrors1.symbols | 7 + .../reference/constraintErrors1.types | 8 + .../baselines/reference/constraints0.symbols | 43 + tests/baselines/reference/constraints0.types | 43 + ...ignatureAssignabilityInInheritance.symbols | 158 + ...tSignatureAssignabilityInInheritance.types | 160 + ...gnatureAssignabilityInInheritance3.symbols | 377 + ...SignatureAssignabilityInInheritance3.types | 377 + ...AccessibilityModifiersOnParameters.symbols | 52 + ...thAccessibilityModifiersOnParameters.types | 52 + ...ccessibilityModifiersOnParameters2.symbols | 74 + ...hAccessibilityModifiersOnParameters2.types | 74 + .../constructSignaturesWithOverloads2.symbols | 104 + .../constructSignaturesWithOverloads2.types | 118 + .../constructableDecoratorOnClass01.symbols | 3 +- .../constructableDecoratorOnClass01.types | 1 - .../reference/constructorArgsErrors1.symbols | 8 + .../reference/constructorArgsErrors1.types | 8 + .../reference/constructorArgsErrors2.symbols | 9 + .../reference/constructorArgsErrors2.types | 9 + .../reference/constructorArgsErrors3.symbols | 9 + .../reference/constructorArgsErrors3.types | 9 + .../reference/constructorArgsErrors4.symbols | 9 + .../reference/constructorArgsErrors4.types | 9 + .../reference/constructorArgsErrors5.symbols | 9 + .../reference/constructorArgsErrors5.types | 9 + .../reference/constructorAsType.symbols | 14 + .../reference/constructorAsType.types | 18 + ...ructorDefaultValuesReferencingThis.symbols | 26 + ...structorDefaultValuesReferencingThis.types | 26 + ...orImplementationWithDefaultValues2.symbols | 58 + ...ctorImplementationWithDefaultValues2.types | 61 + ...ructorInvocationWithTooFewTypeArgs.symbols | 20 + ...structorInvocationWithTooFewTypeArgs.types | 21 + .../reference/constructorOverloads1.symbols | 55 + .../reference/constructorOverloads1.types | 64 + .../reference/constructorOverloads3.symbols | 61 + .../reference/constructorOverloads3.types | 69 + .../reference/constructorOverloads4.symbols | 31 + .../reference/constructorOverloads4.types | 37 + .../reference/constructorOverloads5.symbols | 53 + .../reference/constructorOverloads5.types | 53 + .../reference/constructorOverloads6.symbols | 61 + .../reference/constructorOverloads6.types | 69 + .../reference/constructorOverloads7.symbols | 55 + .../reference/constructorOverloads7.types | 65 + .../reference/constructorOverloads8.symbols | 35 + .../reference/constructorOverloads8.types | 35 + ...structorOverloadsWithDefaultValues.symbols | 27 + ...onstructorOverloadsWithDefaultValues.types | 29 + .../constructorParameterProperties.symbols | 77 + .../constructorParameterProperties.types | 79 + .../constructorParameterProperties2.symbols | 81 + .../constructorParameterProperties2.types | 81 + ...tructorParameterShadowsOuterScopes.symbols | 39 + ...nstructorParameterShadowsOuterScopes.types | 46 + ...orParametersInVariableDeclarations.symbols | 37 + ...ctorParametersInVariableDeclarations.types | 48 + ...xternalNamesInVariableDeclarations.symbols | 26 + ...wExternalNamesInVariableDeclarations.types | 30 + .../constructorReturnsInvalidType.symbols | 15 + .../constructorReturnsInvalidType.types | 17 + .../constructorStaticParamName.symbols | 10 + .../constructorStaticParamName.types | 10 + .../constructorStaticParamNameErrors.symbols | 9 + .../constructorStaticParamNameErrors.types | 11 + ...ctorWithAssignableReturnExpression.symbols | 62 + ...ructorWithAssignableReturnExpression.types | 71 + ...ructorWithIncompleteTypeAnnotation.symbols | 654 + ...structorWithIncompleteTypeAnnotation.types | 983 + ...structorsWithSpecializedSignatures.symbols | 90 + ...onstructorsWithSpecializedSignatures.types | 90 + .../reference/contextualTypeAny.symbols | 15 + .../reference/contextualTypeAny.types | 19 + .../reference/contextualTypeWithTuple.symbols | 82 + .../reference/contextualTypeWithTuple.types | 132 + ...tualTypeWithUnionTypeObjectLiteral.symbols | 212 + ...extualTypeWithUnionTypeObjectLiteral.types | 229 + .../reference/contextualTyping.symbols | 732 + .../reference/contextualTyping.types | 972 + .../reference/contextualTyping11.symbols | 7 + .../reference/contextualTyping11.types | 11 + .../reference/contextualTyping12.symbols | 9 + .../reference/contextualTyping12.types | 15 + .../reference/contextualTyping17.symbols | 9 + .../reference/contextualTyping17.types | 15 + .../reference/contextualTyping2.symbols | 7 + .../reference/contextualTyping2.types | 10 + .../reference/contextualTyping20.symbols | 10 + .../reference/contextualTyping20.types | 20 + .../reference/contextualTyping21.symbols | 8 + .../reference/contextualTyping21.types | 16 + .../reference/contextualTyping24.symbols | 9 + .../reference/contextualTyping24.types | 12 + .../reference/contextualTyping30.symbols | 6 + .../reference/contextualTyping30.types | 10 + .../reference/contextualTyping33.symbols | 7 + .../reference/contextualTyping33.types | 13 + .../reference/contextualTyping39.symbols | 4 + .../reference/contextualTyping39.types | 7 + .../reference/contextualTyping4.symbols | 8 + .../reference/contextualTyping4.types | 11 + .../reference/contextualTyping41.symbols | 5 + .../reference/contextualTyping41.types | 9 + .../reference/contextualTyping5.symbols | 6 + .../reference/contextualTyping5.types | 7 + .../reference/contextualTyping9.symbols | 8 + .../reference/contextualTyping9.types | 14 + .../contextualTypingOfAccessors.symbols | 27 + .../contextualTypingOfAccessors.types | 30 + .../contextualTypingOfArrayLiterals1.symbols | 23 + .../contextualTypingOfArrayLiterals1.types | 29 + ...tualTypingOfConditionalExpression2.symbols | 33 + ...extualTypingOfConditionalExpression2.types | 37 + ...ngOfGenericFunctionTypedArguments1.symbols | 69 + ...pingOfGenericFunctionTypedArguments1.types | 75 + ...tualTypingOfLambdaReturnExpression.symbols | 25 + ...extualTypingOfLambdaReturnExpression.types | 33 + .../contextualTypingOfObjectLiterals2.symbols | 19 + .../contextualTypingOfObjectLiterals2.types | 24 + ...tualTypingWithFixedTypeParameters1.symbols | 24 + ...extualTypingWithFixedTypeParameters1.types | 39 + .../contextuallyTypeCommaOperator02.symbols | 17 + .../contextuallyTypeCommaOperator02.types | 22 + .../contextuallyTypeCommaOperator03.symbols | 12 + .../contextuallyTypeCommaOperator03.types | 17 + .../contextuallyTypeLogicalAnd02.symbols | 21 + .../contextuallyTypeLogicalAnd02.types | 26 + .../contextuallyTypeLogicalAnd03.symbols | 15 + .../contextuallyTypeLogicalAnd03.types | 22 + ...ClassExpressionMethodDeclaration01.symbols | 94 + ...edClassExpressionMethodDeclaration01.types | 128 + ...ClassExpressionMethodDeclaration02.symbols | 101 + ...edClassExpressionMethodDeclaration02.types | 135 + .../contextuallyTypedIifeStrict.symbols | 16 +- .../contextuallyTypedIifeStrict.types | 64 +- ...pedStringLiteralsInJsxAttributes01.symbols | 44 + ...TypedStringLiteralsInJsxAttributes01.types | 52 + ...pedStringLiteralsInJsxAttributes02.symbols | 138 + ...TypedStringLiteralsInJsxAttributes02.types | 165 + .../contextuallyTypingRestParameters.symbols | 27 + .../contextuallyTypingRestParameters.types | 28 + .../continueInIterationStatement4.symbols | 6 + .../continueInIterationStatement4.types | 7 + .../continueNotInIterationStatement1.symbols | 3 + .../continueNotInIterationStatement1.types | 3 + .../continueNotInIterationStatement2.symbols | 8 + .../continueNotInIterationStatement2.types | 10 + .../continueNotInIterationStatement3.symbols | 6 + .../continueNotInIterationStatement3.types | 7 + .../continueNotInIterationStatement4.symbols | 10 + .../continueNotInIterationStatement4.types | 16 + .../reference/continueTarget1.symbols | 4 + .../baselines/reference/continueTarget1.types | 7 + .../reference/continueTarget5.symbols | 11 + .../baselines/reference/continueTarget5.types | 18 + .../reference/continueTarget6.symbols | 5 + .../baselines/reference/continueTarget6.types | 7 + .../reference/controlFlowArrayErrors.symbols | 172 + .../reference/controlFlowArrayErrors.types | 215 + .../controlFlowDeleteOperator.symbols | 75 +- .../reference/controlFlowDeleteOperator.types | 1 - .../controlFlowIterationErrors.symbols | 224 + .../controlFlowIterationErrors.types | 265 + .../reference/controlFlowLoopAnalysis.symbols | 129 + .../reference/controlFlowLoopAnalysis.types | 146 + .../controlFlowNoImplicitAny.symbols | 262 + .../reference/controlFlowNoImplicitAny.types | 305 + .../controlFlowSelfReferentialLoop.symbols | 833 + .../controlFlowSelfReferentialLoop.types | 1262 + .../reference/convertKeywordsYes.symbols | 878 + .../reference/convertKeywordsYes.types | 1006 + .../reference/copyrightWithNewLine1.symbols | 20 + .../reference/copyrightWithNewLine1.types | 31 + .../copyrightWithoutNewLine1.symbols | 19 + .../reference/copyrightWithoutNewLine1.types | 30 + .../correctOrderOfPromiseMethod.symbols | 4 +- .../couldNotSelectGenericOverload.symbols | 30 + .../couldNotSelectGenericOverload.types | 40 + .../reference/covariantCallbacks.symbols | 207 + .../reference/covariantCallbacks.types | 219 + ...ropertyIsRelatableToTargetProperty.symbols | 30 + ...ePropertyIsRelatableToTargetProperty.types | 35 + ...ashIntypeCheckInvocationExpression.symbols | 37 + ...crashIntypeCheckInvocationExpression.types | 49 + ...ntypeCheckObjectCreationExpression.symbols | 26 + ...hIntypeCheckObjectCreationExpression.types | 29 + .../reference/crashOnMethodSignatures.symbols | 9 + .../reference/crashOnMethodSignatures.types | 9 + .../reference/crashRegressionTest.symbols | 61 + .../reference/crashRegressionTest.types | 69 + tests/baselines/reference/createArray.symbols | 33 + tests/baselines/reference/createArray.types | 56 + .../reference/customEventDetail.symbols | 14 + .../reference/customEventDetail.types | 28 + .../reference/declFileGenericType2.symbols | 34 +- ...AnnotationVisibilityErrorAccessors.symbols | 181 + ...peAnnotationVisibilityErrorAccessors.types | 187 + ...VisibilityErrorParameterOfFunction.symbols | 94 + ...onVisibilityErrorParameterOfFunction.types | 100 + ...isibilityErrorReturnTypeOfFunction.symbols | 106 + ...nVisibilityErrorReturnTypeOfFunction.types | 112 + ...AnnotationVisibilityErrorTypeAlias.symbols | 90 + ...peAnnotationVisibilityErrorTypeAlias.types | 90 + ...notationVisibilityErrorTypeLiteral.symbols | 93 + ...AnnotationVisibilityErrorTypeLiteral.types | 97 + ...VisibilityErrorVariableDeclaration.symbols | 76 + ...onVisibilityErrorVariableDeclaration.types | 82 + ...leWithErrorsInInputDeclarationFile.symbols | 25 + ...FileWithErrorsInInputDeclarationFile.types | 26 + ...rrorsInInputDeclarationFileWithOut.symbols | 25 + ...hErrorsInInputDeclarationFileWithOut.types | 26 + tests/baselines/reference/declInput-2.symbols | 73 + tests/baselines/reference/declInput-2.types | 77 + ...rationEmitClassPrivateConstructor2.symbols | 21 + ...larationEmitClassPrivateConstructor2.types | 21 + .../declarationEmitDefaultExport7.symbols | 7 + .../declarationEmitDefaultExport7.types | 8 + .../declarationEmitDestructuring2.symbols | 44 + .../declarationEmitDestructuring2.types | 68 + .../declarationEmitDestructuring4.symbols | 21 + .../declarationEmitDestructuring4.types | 32 + ...tionEmitDestructuringArrayPattern2.symbols | 40 + ...rationEmitDestructuringArrayPattern2.types | 70 + ...tDestructuringObjectLiteralPattern.symbols | 88 + ...mitDestructuringObjectLiteralPattern.types | 121 + ...DestructuringObjectLiteralPattern1.symbols | 41 + ...itDestructuringObjectLiteralPattern1.types | 62 + ...itDestructuringParameterProperties.symbols | 41 + ...EmitDestructuringParameterProperties.types | 41 + ...ationEmitDestructuringPrivacyError.symbols | 13 + ...arationEmitDestructuringPrivacyError.types | 17 + ...uringWithOptionalBindingParameters.symbols | 16 + ...cturingWithOptionalBindingParameters.types | 16 + ...eclarationEmitExpressionInExtends3.symbols | 93 + .../declarationEmitExpressionInExtends3.types | 97 + ...eclarationEmitExpressionInExtends4.symbols | 24 + .../declarationEmitExpressionInExtends4.types | 29 + ...ntifierPredicatesWithPrivateName01.symbols | 17 + ...dentifierPredicatesWithPrivateName01.types | 22 + .../declarationEmitIndexTypeNotFound.symbols | 8 + .../declarationEmitIndexTypeNotFound.types | 9 + ...ithNonEntityNameExpressionHeritage.symbols | 8 + ...eWithNonEntityNameExpressionHeritage.types | 10 + .../declarationEmitInvalidExport.symbols | 10 + .../declarationEmitInvalidExport.types | 13 + .../declarationEmitInvalidReference2.symbols | 5 + .../declarationEmitInvalidReference2.types | 6 + .../declarationEmitThisPredicates02.symbols | 37 + .../declarationEmitThisPredicates02.types | 49 + ...mitThisPredicatesWithPrivateName01.symbols | 18 + ...nEmitThisPredicatesWithPrivateName01.types | 19 + ...mitThisPredicatesWithPrivateName02.symbols | 37 + ...nEmitThisPredicatesWithPrivateName02.types | 49 + ...ypeParameterExtendingUnknownSymbol.symbols | 5 + ...sTypeParameterExtendingUnknownSymbol.types | 6 + ...onEmitTypeAliasWithTypeParameters5.symbols | 28 + ...tionEmitTypeAliasWithTypeParameters5.types | 30 + .../declarationEmitUnknownImport.symbols | 7 + .../declarationEmitUnknownImport.types | 8 + .../declarationEmitUnknownImport2.symbols | 7 + .../declarationEmitUnknownImport2.types | 9 + .../declarationFileOverwriteError.symbols | 9 + .../declarationFileOverwriteError.types | 9 + ...clarationFileOverwriteErrorWithOut.symbols | 9 + ...declarationFileOverwriteErrorWithOut.types | 9 + .../reference/declarationFiles.symbols | 126 + .../reference/declarationFiles.types | 136 + .../declarationWithNoInitializer.symbols | 9 + .../declarationWithNoInitializer.types | 9 + .../declarationsAndAssignments.symbols | 571 + .../declarationsAndAssignments.types | 866 + .../reference/declareAlreadySeen.symbols | 16 + .../reference/declareAlreadySeen.types | 16 + ...eclareClassInterfaceImplementation.symbols | 14 + .../declareClassInterfaceImplementation.types | 14 + .../declareModifierOnImport1.symbols | 4 + .../reference/declareModifierOnImport1.types | 5 + .../declaredClassMergedwithSelf.symbols | 24 + .../declaredClassMergedwithSelf.types | 24 + .../reference/decoratorCallGeneric.symbols | 33 + .../reference/decoratorCallGeneric.types | 33 + .../decoratorChecksFunctionBodies.symbols | 30 + .../decoratorChecksFunctionBodies.types | 34 + .../reference/decoratorInJsFile.symbols | 11 + .../reference/decoratorInJsFile.types | 13 + .../reference/decoratorInJsFile1.symbols | 11 + .../reference/decoratorInJsFile1.types | 13 + ...ithImportDeclarationNameCollision4.symbols | 51 + ...aWithImportDeclarationNameCollision4.types | 55 + ...ithImportDeclarationNameCollision7.symbols | 47 + ...aWithImportDeclarationNameCollision7.types | 55 + .../decoratorOnArrowFunction.symbols | 12 + .../reference/decoratorOnArrowFunction.types | 14 + .../reference/decoratorOnClass3.symbols | 15 + .../reference/decoratorOnClass3.types | 15 + .../reference/decoratorOnClass8.symbols | 13 + .../reference/decoratorOnClass8.types | 14 + .../decoratorOnClassAccessor3.symbols | 20 + .../reference/decoratorOnClassAccessor3.types | 21 + .../decoratorOnClassAccessor6.symbols | 21 + .../reference/decoratorOnClassAccessor6.types | 21 + .../decoratorOnClassAccessor7.symbols | 96 + .../reference/decoratorOnClassAccessor7.types | 102 + .../decoratorOnClassConstructor1.symbols | 18 + .../decoratorOnClassConstructor1.types | 18 + .../decoratorOnClassConstructor2.symbols | 10 +- .../decoratorOnClassConstructor2.types | 11 +- ...oratorOnClassConstructorParameter4.symbols | 16 + ...ecoratorOnClassConstructorParameter4.types | 16 + .../decoratorOnClassMethod10.symbols | 14 + .../reference/decoratorOnClassMethod10.types | 14 + .../decoratorOnClassMethod11.symbols | 18 + .../reference/decoratorOnClassMethod11.types | 22 + .../decoratorOnClassMethod12.symbols | 22 + .../reference/decoratorOnClassMethod12.types | 26 + .../reference/decoratorOnClassMethod3.symbols | 20 + .../reference/decoratorOnClassMethod3.types | 20 + .../reference/decoratorOnClassMethod6.symbols | 19 + .../reference/decoratorOnClassMethod6.types | 19 + .../reference/decoratorOnClassMethod8.symbols | 15 + .../reference/decoratorOnClassMethod8.types | 15 + .../decoratorOnClassMethodOverload1.symbols | 24 + .../decoratorOnClassMethodOverload1.types | 24 + .../decoratorOnClassProperty11.symbols | 14 + .../decoratorOnClassProperty11.types | 14 + .../decoratorOnClassProperty3.symbols | 14 + .../reference/decoratorOnClassProperty3.types | 14 + .../decoratorOnClassProperty6.symbols | 13 + .../reference/decoratorOnClassProperty6.types | 13 + .../decoratorOnClassProperty7.symbols | 15 + .../reference/decoratorOnClassProperty7.types | 15 + .../reference/decoratorOnEnum.symbols | 14 + .../baselines/reference/decoratorOnEnum.types | 14 + .../reference/decoratorOnEnum2.symbols | 14 + .../reference/decoratorOnEnum2.types | 15 + .../decoratorOnFunctionDeclaration.symbols | 14 + .../decoratorOnFunctionDeclaration.types | 14 + .../decoratorOnFunctionExpression.symbols | 13 + .../decoratorOnFunctionExpression.types | 14 + .../decoratorOnImportEquals1.symbols | 26 + .../reference/decoratorOnImportEquals1.types | 26 + .../decoratorOnImportEquals2.symbols | 18 + .../reference/decoratorOnImportEquals2.types | 18 + .../reference/decoratorOnInterface.symbols | 14 + .../reference/decoratorOnInterface.types | 14 + .../decoratorOnInternalModule.symbols | 15 + .../reference/decoratorOnInternalModule.types | 15 + .../reference/decoratorOnTypeAlias.symbols | 14 + .../reference/decoratorOnTypeAlias.types | 14 + .../reference/decoratorOnVar.symbols | 14 + .../baselines/reference/decoratorOnVar.types | 14 + .../decrementAndIncrementOperators.symbols | 64 + .../decrementAndIncrementOperators.types | 132 + ...rWithAnyOtherTypeInvalidOperations.symbols | 207 + ...torWithAnyOtherTypeInvalidOperations.types | 296 + .../decrementOperatorWithEnumType.symbols | 28 + .../decrementOperatorWithEnumType.types | 36 + ...ratorWithEnumTypeInvalidOperations.symbols | 52 + ...peratorWithEnumTypeInvalidOperations.types | 74 + ...torWithNumberTypeInvalidOperations.symbols | 117 + ...ratorWithNumberTypeInvalidOperations.types | 171 + ...OperatorWithUnsupportedBooleanType.symbols | 164 + ...ntOperatorWithUnsupportedBooleanType.types | 222 + ...tOperatorWithUnsupportedStringType.symbols | 205 + ...entOperatorWithUnsupportedStringType.types | 288 + .../deduplicateImportsInSystem.symbols | 27 + .../deduplicateImportsInSystem.types | 36 + .../defaultArgsInFunctionExpressions.symbols | 89 + .../defaultArgsInFunctionExpressions.types | 120 + .../reference/defaultArgsInOverloads.symbols | 57 + .../reference/defaultArgsInOverloads.types | 65 + .../defaultBestCommonTypesHaveDecls.symbols | 49 + .../defaultBestCommonTypesHaveDecls.types | 65 + .../defaultExportsCannotMerge01.symbols | 53 + .../defaultExportsCannotMerge01.types | 61 + .../defaultExportsCannotMerge02.symbols | 48 + .../defaultExportsCannotMerge02.types | 55 + .../defaultExportsCannotMerge03.symbols | 48 + .../defaultExportsCannotMerge03.types | 55 + .../defaultExportsCannotMerge04.symbols | 19 + .../defaultExportsCannotMerge04.types | 19 + ...defaultValueInConstructorOverload1.symbols | 11 + .../defaultValueInConstructorOverload1.types | 13 + .../defaultValueInFunctionOverload1.symbols | 9 + .../defaultValueInFunctionOverload1.types | 11 + .../defaultValueInFunctionTypes.symbols | 10 + .../defaultValueInFunctionTypes.types | 14 + .../deferredLookupTypeResolution2.symbols | 70 + .../deferredLookupTypeResolution2.types | 70 + .../reference/deleteOperator1.symbols | 16 + .../baselines/reference/deleteOperator1.types | 19 + .../deleteOperatorInStrictMode.symbols | 8 + .../deleteOperatorInStrictMode.types | 11 + .../deleteOperatorInvalidOperations.symbols | 25 + .../deleteOperatorInvalidOperations.types | 30 + .../deleteOperatorWithAnyOtherType.symbols | 188 + .../deleteOperatorWithAnyOtherType.types | 248 + .../reference/deleteReadonly.symbols | 41 + .../baselines/reference/deleteReadonly.types | 57 + ...edClassConstructorWithoutSuperCall.symbols | 63 + ...ivedClassConstructorWithoutSuperCall.types | 70 + ...FunctionOverridesBaseClassAccessor.symbols | 26 + ...ssFunctionOverridesBaseClassAccessor.types | 28 + ...rivedClassIncludesInheritedMembers.symbols | 120 + ...derivedClassIncludesInheritedMembers.types | 134 + ...ivedClassOverridesPrivateFunction1.symbols | 29 + ...erivedClassOverridesPrivateFunction1.types | 32 + .../derivedClassOverridesPrivates.symbols | 36 + .../derivedClassOverridesPrivates.types | 36 + ...vedClassOverridesProtectedMembers3.symbols | 221 + ...rivedClassOverridesProtectedMembers3.types | 231 + ...vedClassOverridesProtectedMembers4.symbols | 35 + ...rivedClassOverridesProtectedMembers4.types | 35 + ...derivedClassOverridesPublicMembers.symbols | 227 + .../derivedClassOverridesPublicMembers.types | 237 + .../derivedClassParameterProperties.symbols | 236 + .../derivedClassParameterProperties.types | 276 + ...sSuperCallsInNonConstructorMembers.symbols | 56 + ...assSuperCallsInNonConstructorMembers.types | 78 + .../derivedClassSuperCallsWithThisArg.symbols | 59 + .../derivedClassSuperCallsWithThisArg.types | 66 + .../derivedClassTransitivity.symbols | 56 + .../reference/derivedClassTransitivity.types | 61 + .../derivedClassTransitivity2.symbols | 59 + .../reference/derivedClassTransitivity2.types | 66 + .../derivedClassTransitivity3.symbols | 68 + .../reference/derivedClassTransitivity3.types | 75 + .../derivedClassTransitivity4.symbols | 56 + .../reference/derivedClassTransitivity4.types | 61 + .../reference/derivedClassWithAny.symbols | 122 + .../reference/derivedClassWithAny.types | 137 + ...InstanceShadowingProtectedInstance.symbols | 43 + ...teInstanceShadowingProtectedInstance.types | 47 + ...ateInstanceShadowingPublicInstance.symbols | 73 + ...ivateInstanceShadowingPublicInstance.types | 99 + ...vateStaticShadowingProtectedStatic.symbols | 42 + ...rivateStaticShadowingProtectedStatic.types | 46 + ...PrivateStaticShadowingPublicStatic.symbols | 90 + ...thPrivateStaticShadowingPublicStatic.types | 100 + ...vedClassWithoutExplicitConstructor.symbols | 75 + ...rivedClassWithoutExplicitConstructor.types | 88 + ...edClassWithoutExplicitConstructor2.symbols | 119 + ...ivedClassWithoutExplicitConstructor2.types | 146 + ...edClassWithoutExplicitConstructor3.symbols | 136 + ...ivedClassWithoutExplicitConstructor3.types | 163 + .../reference/derivedClasses.symbols | 77 + .../baselines/reference/derivedClasses.types | 95 + .../derivedGenericClassWithAny.symbols | 102 + .../derivedGenericClassWithAny.types | 113 + .../derivedInterfaceCallSignature.symbols | 109 + .../derivedInterfaceCallSignature.types | 113 + ...terfaceIncompatibleWithBaseIndexer.symbols | 64 + ...InterfaceIncompatibleWithBaseIndexer.types | 64 + ...ddenBaseCallViaSuperPropertyAccess.symbols | 56 + ...HiddenBaseCallViaSuperPropertyAccess.types | 69 + ...eCallingBaseImplWithOptionalParams.symbols | 38 + ...ypeCallingBaseImplWithOptionalParams.types | 42 + .../derivedTypeIncompatibleSignatures.symbols | 60 + .../derivedTypeIncompatibleSignatures.types | 60 + ...rayBindingPatternAndAssignment1ES5.symbols | 105 + ...ArrayBindingPatternAndAssignment1ES5.types | 177 + ...ngPatternAndAssignment1ES5iterable.symbols | 105 + ...dingPatternAndAssignment1ES5iterable.types | 177 + ...rayBindingPatternAndAssignment1ES6.symbols | 104 + ...ArrayBindingPatternAndAssignment1ES6.types | 176 + ...gArrayBindingPatternAndAssignment2.symbols | 77 + ...ingArrayBindingPatternAndAssignment2.types | 102 + ...gArrayBindingPatternAndAssignment3.symbols | 47 + ...ingArrayBindingPatternAndAssignment3.types | 70 + ...ObjectBindingPatternAndAssignment3.symbols | 25 + ...ngObjectBindingPatternAndAssignment3.types | 38 + ...ObjectBindingPatternAndAssignment4.symbols | 26 + ...ngObjectBindingPatternAndAssignment4.types | 30 + ...tructuringParameterDeclaration1ES5.symbols | 327 + ...estructuringParameterDeclaration1ES5.types | 439 + ...ngParameterDeclaration1ES5iterable.symbols | 327 + ...ringParameterDeclaration1ES5iterable.types | 439 + ...tructuringParameterDeclaration1ES6.symbols | 325 + ...estructuringParameterDeclaration1ES6.types | 422 + ...destructuringParameterDeclaration2.symbols | 207 + .../destructuringParameterDeclaration2.types | 277 + ...tructuringParameterDeclaration3ES5.symbols | 8 +- ...tructuringParameterDeclaration3ES6.symbols | 8 +- ...destructuringParameterDeclaration4.symbols | 97 + .../destructuringParameterDeclaration4.types | 139 + ...destructuringParameterDeclaration5.symbols | 153 + .../destructuringParameterDeclaration5.types | 201 + ...destructuringParameterDeclaration6.symbols | 55 + .../destructuringParameterDeclaration6.types | 75 + .../destructuringParameterProperties1.symbols | 90 + .../destructuringParameterProperties1.types | 141 + .../destructuringParameterProperties2.symbols | 100 + .../destructuringParameterProperties2.types | 156 + .../destructuringParameterProperties3.symbols | 133 + .../destructuringParameterProperties3.types | 191 + .../destructuringParameterProperties4.symbols | 70 + .../destructuringParameterProperties4.types | 100 + .../destructuringParameterProperties5.symbols | 59 + .../destructuringParameterProperties5.types | 96 + .../destructuringTypeAssertionsES5_1.symbols | 4 + .../destructuringTypeAssertionsES5_1.types | 7 + .../destructuringTypeAssertionsES5_2.symbols | 4 + .../destructuringTypeAssertionsES5_2.types | 8 + .../destructuringTypeAssertionsES5_3.symbols | 4 + .../destructuringTypeAssertionsES5_3.types | 8 + .../destructuringTypeAssertionsES5_4.symbols | 4 + .../destructuringTypeAssertionsES5_4.types | 8 + .../destructuringTypeAssertionsES5_6.symbols | 4 + .../destructuringTypeAssertionsES5_6.types | 7 + .../destructuringTypeAssertionsES5_7.symbols | 4 + .../destructuringTypeAssertionsES5_7.types | 8 + .../destructuringVariableDeclaration2.symbols | 54 + .../destructuringVariableDeclaration2.types | 90 + ...achedCommentAtStartOfFunctionBody1.symbols | 16 + ...etachedCommentAtStartOfFunctionBody1.types | 20 + ...achedCommentAtStartOfFunctionBody2.symbols | 17 + ...etachedCommentAtStartOfFunctionBody2.types | 21 + .../differentTypesWithSameName.symbols | 38 + .../differentTypesWithSameName.types | 40 + ...directDependenceBetweenTypeAliases.symbols | 113 + .../directDependenceBetweenTypeAliases.types | 114 + .../reference/directReferenceToNull.symbols | 4 + .../reference/directReferenceToNull.types | 5 + .../directReferenceToUndefined.symbols | 8 + .../directReferenceToUndefined.types | 9 + .../disallowLineTerminatorBeforeArrow.symbols | 175 + .../disallowLineTerminatorBeforeArrow.types | 218 + .../discriminantPropertyCheck.symbols | 230 + .../reference/discriminantPropertyCheck.types | 252 + .../discriminatedUnionErrorMessage.symbols | 43 + .../discriminatedUnionErrorMessage.types | 47 + .../discriminatedUnionTypes1.symbols | 402 + .../reference/discriminatedUnionTypes1.types | 465 + .../dontShowCompilerGeneratedMembers.symbols | 9 + .../dontShowCompilerGeneratedMembers.types | 13 + .../reference/dottedModuleName.symbols | 44 + .../reference/dottedModuleName.types | 50 + ...bleUnderStringLiteralAssignability.symbols | 13 + ...oubleUnderStringLiteralAssignability.types | 17 + ...doubleUnderscoreExportStarConflict.symbols | 12 + .../doubleUnderscoreExportStarConflict.types | 12 + .../reference/downlevelLetConst1.symbols | 3 + .../reference/downlevelLetConst1.types | 3 + .../reference/downlevelLetConst11.symbols | 4 + .../reference/downlevelLetConst11.types | 7 + .../reference/downlevelLetConst12.symbols | 25 + .../reference/downlevelLetConst12.types | 34 + .../reference/downlevelLetConst16.symbols | 577 + .../reference/downlevelLetConst16.types | 727 + .../reference/downlevelLetConst18.symbols | 58 + .../reference/downlevelLetConst18.types | 72 + .../reference/downlevelLetConst19.symbols | 42 + .../reference/downlevelLetConst19.types | 49 + .../reference/downlevelLetConst2.symbols | 4 + .../reference/downlevelLetConst2.types | 4 + .../reference/downlevelLetConst4.symbols | 4 + .../reference/downlevelLetConst4.types | 4 + .../reference/downlevelLetConst6.symbols | 3 + .../reference/downlevelLetConst6.types | 4 + .../reference/duplicateClassElements.symbols | 78 + .../reference/duplicateClassElements.types | 83 + .../duplicateExportAssignments.symbols | 81 + .../duplicateExportAssignments.types | 90 + ...dingElementInParameterDeclaration1.symbols | 52 + ...indingElementInParameterDeclaration1.types | 54 + ...dingElementInParameterDeclaration2.symbols | 53 + ...indingElementInParameterDeclaration2.types | 57 + .../duplicateIdentifierComputedName.symbols | 11 + .../duplicateIdentifierComputedName.types | 11 + ...licateIdentifierDifferentModifiers.symbols | 40 + ...uplicateIdentifierDifferentModifiers.types | 40 + ...plicateIdentifierDifferentSpelling.symbols | 11 + ...duplicateIdentifierDifferentSpelling.types | 17 + .../duplicateIdentifierInCatchBlock.symbols | 39 + .../duplicateIdentifierInCatchBlock.types | 39 + ...entifiersAcrossContainerBoundaries.symbols | 97 + ...IdentifiersAcrossContainerBoundaries.types | 99 + ...ateIdentifiersAcrossFileBoundaries.symbols | 64 + ...icateIdentifiersAcrossFileBoundaries.types | 66 + .../duplicateInterfaceMembers1.symbols | 11 + .../duplicateInterfaceMembers1.types | 11 + .../reference/duplicateLabel1.symbols | 6 + .../baselines/reference/duplicateLabel1.types | 10 + .../reference/duplicateLabel2.symbols | 8 + .../baselines/reference/duplicateLabel2.types | 14 + .../reference/duplicateLocalVariable1.symbols | 1014 + .../reference/duplicateLocalVariable1.types | 1879 + .../reference/duplicateLocalVariable2.symbols | 94 + .../reference/duplicateLocalVariable2.types | 129 + .../reference/duplicateLocalVariable3.symbols | 26 + .../reference/duplicateLocalVariable3.types | 32 + .../reference/duplicateLocalVariable4.symbols | 18 + .../reference/duplicateLocalVariable4.types | 18 + .../duplicateNumericIndexers.symbols | 67 + .../reference/duplicateNumericIndexers.types | 67 + .../duplicateObjectLiteralProperty.symbols | 42 + .../duplicateObjectLiteralProperty.types | 53 + .../reference/duplicatePackage.symbols | 65 + .../reference/duplicatePackage.types | 67 + .../duplicatePackage_withErrors.symbols | 25 + .../duplicatePackage_withErrors.types | 31 + .../duplicatePropertiesInStrictMode.symbols | 11 + .../duplicatePropertiesInStrictMode.types | 16 + ...licatePropertiesInTypeAssertions01.symbols | 6 + ...uplicatePropertiesInTypeAssertions01.types | 8 + ...licatePropertiesInTypeAssertions02.symbols | 6 + ...uplicatePropertiesInTypeAssertions02.types | 8 + .../reference/duplicatePropertyNames.symbols | 102 + .../reference/duplicatePropertyNames.types | 109 + .../reference/duplicateStringIndexers.symbols | 70 + .../reference/duplicateStringIndexers.types | 70 + .../duplicateStringNamedProperty1.symbols | 8 + .../duplicateStringNamedProperty1.types | 8 + .../duplicateSymbolsExportMatching.symbols | 135 + .../duplicateSymbolsExportMatching.types | 135 + .../duplicateTypeParameters1.symbols | 6 + .../reference/duplicateTypeParameters1.types | 6 + .../duplicateTypeParameters2.symbols | 16 + .../reference/duplicateTypeParameters2.types | 16 + .../duplicateTypeParameters3.symbols | 11 + .../reference/duplicateTypeParameters3.types | 11 + .../reference/duplicateVarAndImport2.symbols | 13 + .../reference/duplicateVarAndImport2.types | 14 + .../duplicateVariablesWithAny.symbols | 36 + .../reference/duplicateVariablesWithAny.types | 40 + .../duplicateVarsAcrossFileBoundaries.symbols | 56 + .../duplicateVarsAcrossFileBoundaries.types | 66 + .../reference/elaboratedErrors.symbols | 67 + .../reference/elaboratedErrors.types | 71 + ...tArrowFunctionWhenUsingArguments01.symbols | 62 + ...mitArrowFunctionWhenUsingArguments01.types | 83 + ...tArrowFunctionWhenUsingArguments02.symbols | 5 + ...mitArrowFunctionWhenUsingArguments02.types | 6 + ...tArrowFunctionWhenUsingArguments03.symbols | 8 + ...mitArrowFunctionWhenUsingArguments03.types | 9 + ...tArrowFunctionWhenUsingArguments04.symbols | 11 + ...mitArrowFunctionWhenUsingArguments04.types | 12 + ...tArrowFunctionWhenUsingArguments05.symbols | 9 + ...mitArrowFunctionWhenUsingArguments05.types | 10 + ...tArrowFunctionWhenUsingArguments06.symbols | 9 + ...mitArrowFunctionWhenUsingArguments06.types | 11 + ...tArrowFunctionWhenUsingArguments07.symbols | 10 + ...mitArrowFunctionWhenUsingArguments07.types | 12 + ...tArrowFunctionWhenUsingArguments09.symbols | 9 + ...mitArrowFunctionWhenUsingArguments09.types | 11 + ...tArrowFunctionWhenUsingArguments10.symbols | 11 + ...mitArrowFunctionWhenUsingArguments10.types | 14 + ...tArrowFunctionWhenUsingArguments11.symbols | 12 + ...mitArrowFunctionWhenUsingArguments11.types | 15 + ...tArrowFunctionWhenUsingArguments12.symbols | 13 + ...mitArrowFunctionWhenUsingArguments12.types | 14 + ...owFunctionWhenUsingArguments12_ES6.symbols | 13 + ...rrowFunctionWhenUsingArguments12_ES6.types | 14 + ...tArrowFunctionWhenUsingArguments14.symbols | 16 + ...mitArrowFunctionWhenUsingArguments14.types | 19 + ...tArrowFunctionWhenUsingArguments15.symbols | 19 + ...mitArrowFunctionWhenUsingArguments15.types | 23 + ...tArrowFunctionWhenUsingArguments16.symbols | 18 + ...mitArrowFunctionWhenUsingArguments16.types | 24 + ...tArrowFunctionWhenUsingArguments17.symbols | 19 + ...mitArrowFunctionWhenUsingArguments17.types | 26 + ...tArrowFunctionWhenUsingArguments18.symbols | 18 + ...mitArrowFunctionWhenUsingArguments18.types | 21 + ...tArrowFunctionWhenUsingArguments19.symbols | 30 + ...mitArrowFunctionWhenUsingArguments19.types | 34 + ...CapturingThisInTupleDestructuring1.symbols | 13 + ...itCapturingThisInTupleDestructuring1.types | 26 + ...CapturingThisInTupleDestructuring2.symbols | 32 + ...itCapturingThisInTupleDestructuring2.types | 38 + ...tClassExpressionInDeclarationFile2.symbols | 75 + ...mitClassExpressionInDeclarationFile2.types | 85 + .../emitThisInSuperMethodCall.symbols | 46 + .../reference/emitThisInSuperMethodCall.types | 62 + .../reference/emptyGenericParamList.symbols | 9 + .../reference/emptyGenericParamList.types | 9 + .../reference/emptyMemberAccess.symbols | 8 + .../reference/emptyMemberAccess.types | 13 + .../reference/emptyModuleName.symbols | 8 + .../baselines/reference/emptyModuleName.types | 8 + ...ptyObjectBindingPatternParameter04.symbols | 12 + ...emptyObjectBindingPatternParameter04.types | 16 + .../reference/emptyThenWarning.symbols | 10 + .../reference/emptyThenWarning.types | 18 + .../emptyTuplesTypeAssertion01.symbols | 8 + .../emptyTuplesTypeAssertion01.types | 12 + .../emptyTuplesTypeAssertion02.symbols | 8 + .../emptyTuplesTypeAssertion02.types | 12 + .../reference/emptyTypeArgumentList.symbols | 8 + .../reference/emptyTypeArgumentList.types | 9 + .../emptyTypeArgumentListWithNew.symbols | 8 + .../emptyTypeArgumentListWithNew.types | 9 + ...leDeclarationBindingPatterns02_ES5.symbols | 11 + ...ableDeclarationBindingPatterns02_ES5.types | 14 + ...ationBindingPatterns02_ES5iterable.symbols | 11 + ...arationBindingPatterns02_ES5iterable.types | 14 + ...leDeclarationBindingPatterns02_ES6.symbols | 11 + ...ableDeclarationBindingPatterns02_ES6.types | 14 + .../reference/enumAssignability.symbols | 196 + .../reference/enumAssignability.types | 208 + .../enumAssignabilityInInheritance.symbols | 389 + .../enumAssignabilityInInheritance.types | 413 + .../reference/enumAssignmentCompat.symbols | 122 + .../reference/enumAssignmentCompat.types | 127 + .../reference/enumAssignmentCompat2.symbols | 121 + .../reference/enumAssignmentCompat2.types | 126 + .../reference/enumAssignmentCompat3.symbols | 258 + .../reference/enumAssignmentCompat3.types | 280 + .../reference/enumAssignmentCompat5.symbols | 67 + .../reference/enumAssignmentCompat5.types | 88 + tests/baselines/reference/enumBasics1.symbols | 58 + tests/baselines/reference/enumBasics1.types | 61 + .../enumConflictsWithGlobalIdentifier.symbols | 16 + .../enumConflictsWithGlobalIdentifier.types | 20 + tests/baselines/reference/enumErrors.symbols | 91 + tests/baselines/reference/enumErrors.types | 104 + .../reference/enumGenericTypeClash.symbols | 11 + .../reference/enumGenericTypeClash.types | 11 + .../reference/enumIdentifierLiterals.symbols | 10 + .../reference/enumIdentifierLiterals.types | 10 + ...umIsNotASubtypeOfAnythingButNumber.symbols | 297 + ...enumIsNotASubtypeOfAnythingButNumber.types | 299 + ...LiteralAssignableToEnumInsideUnion.symbols | 115 + ...umLiteralAssignableToEnumInsideUnion.types | 127 + .../reference/enumLiteralTypes1.symbols | 38 +- .../reference/enumLiteralTypes2.symbols | 38 +- .../reference/enumLiteralTypes3.symbols | 514 + .../reference/enumLiteralTypes3.types | 570 + .../reference/enumMemberResolution.symbols | 19 + .../reference/enumMemberResolution.types | 24 + .../reference/enumMergingErrors.symbols | 103 + .../reference/enumMergingErrors.types | 111 + .../reference/enumPropertyAccess.symbols | 42 + .../reference/enumPropertyAccess.types | 48 + .../enumUsedBeforeDeclaration.symbols | 28 + .../reference/enumUsedBeforeDeclaration.types | 28 + .../reference/enumWithComputedMember.symbols | 17 + .../reference/enumWithComputedMember.types | 18 + .../enumWithParenthesizedInitializer1.symbols | 7 + .../enumWithParenthesizedInitializer1.types | 10 + .../reference/enumWithPrimitiveName.symbols | 10 + .../reference/enumWithPrimitiveName.types | 10 + .../enumsWithMultipleDeclarations1.symbols | 21 + .../enumsWithMultipleDeclarations1.types | 21 + .../enumsWithMultipleDeclarations2.symbols | 21 + .../enumsWithMultipleDeclarations2.types | 22 + .../reference/equalityStrictNulls.symbols | 141 + .../reference/equalityStrictNulls.types | 187 + .../equalityWithIntersectionTypes01.symbols | 64 + .../equalityWithIntersectionTypes01.types | 80 + .../reference/errorElaboration.symbols | 40 + .../reference/errorElaboration.types | 41 + ...rorForConflictingExportEqualsValue.symbols | 6 + ...errorForConflictingExportEqualsValue.types | 7 + ...rrorForUsingPropertyOfTypeAsType01.symbols | 95 + .../errorForUsingPropertyOfTypeAsType01.types | 127 + ...rwardReferenceForwadingConstructor.symbols | 23 + ...ForwardReferenceForwadingConstructor.types | 26 + .../errorHandlingInInstanceOf.symbols | 11 + .../reference/errorHandlingInInstanceOf.types | 15 + ...errorLocationForInterfaceExtension.symbols | 7 + .../errorLocationForInterfaceExtension.types | 9 + .../errorMessageOnObjectLiteralType.symbols | 17 + .../errorMessageOnObjectLiteralType.types | 24 + .../errorMessagesIntersectionTypes01.symbols | 38 + .../errorMessagesIntersectionTypes01.types | 41 + .../errorMessagesIntersectionTypes02.symbols | 38 + .../errorMessagesIntersectionTypes02.types | 41 + .../errorMessagesIntersectionTypes03.symbols | 69 + .../errorMessagesIntersectionTypes03.types | 75 + .../errorMessagesIntersectionTypes04.symbols | 56 + .../errorMessagesIntersectionTypes04.types | 60 + ...errorOnContextuallyTypedReturnType.symbols | 7 + .../errorOnContextuallyTypedReturnType.types | 9 + ...orOnInitializerInInterfaceProperty.symbols | 8 + ...rrorOnInitializerInInterfaceProperty.types | 9 + ...ializerInObjectTypeLiteralProperty.symbols | 17 + ...itializerInObjectTypeLiteralProperty.types | 19 + .../errorRecoveryInClassDeclaration.symbols | 14 + .../errorRecoveryInClassDeclaration.types | 21 + ...yWithDotFollowedByNamespaceKeyword.symbols | 18 + ...eryWithDotFollowedByNamespaceKeyword.types | 22 + .../reference/errorSuperCalls.symbols | 120 + .../baselines/reference/errorSuperCalls.types | 156 + .../errorSuperPropertyAccess.symbols | 275 + .../reference/errorSuperPropertyAccess.types | 362 + .../reference/errorSupression1.symbols | 14 + .../reference/errorSupression1.types | 21 + .../errorTypesAsTypeArguments.symbols | 11 + .../reference/errorTypesAsTypeArguments.types | 13 + .../reference/errorWithTruncatedType.symbols | 26 + .../reference/errorWithTruncatedType.types | 26 + .../errorsInGenericTypeReference.symbols | 167 + .../errorsInGenericTypeReference.types | 194 + .../reference/errorsOnImportedSymbol.symbols | 21 + .../reference/errorsOnImportedSymbol.types | 29 + .../es3-oldStyleOctalLiteralInEnums.symbols | 10 + .../es3-oldStyleOctalLiteralInEnums.types | 13 + .../es3-oldStyleOctalLiteralTypes.symbols | 7 + .../es3-oldStyleOctalLiteralTypes.types | 9 + .../es5-asyncFunctionWithStatements.symbols | 54 + .../es5-asyncFunctionWithStatements.types | 71 + .../baselines/reference/es5-commonjs3.symbols | 3 +- tests/baselines/reference/es5-commonjs3.types | 1 - .../baselines/reference/es5-commonjs4.symbols | 5 +- tests/baselines/reference/es5-commonjs4.types | 1 - .../es5-oldStyleOctalLiteralInEnums.symbols | 10 + .../es5-oldStyleOctalLiteralInEnums.types | 13 + .../reference/es5ExportEquals.symbols | 7 + .../baselines/reference/es5ExportEquals.types | 7 + .../es5ModuleInternalNamedImports.symbols | 87 + .../es5ModuleInternalNamedImports.types | 88 + .../baselines/reference/es6ClassTest.symbols | 138 + tests/baselines/reference/es6ClassTest.types | 148 + .../baselines/reference/es6ClassTest2.symbols | 352 + tests/baselines/reference/es6ClassTest2.types | 427 + .../baselines/reference/es6ClassTest9.symbols | 7 + tests/baselines/reference/es6ClassTest9.types | 9 + .../reference/es6DeclOrdering.symbols | 25 + .../baselines/reference/es6DeclOrdering.types | 32 + .../reference/es6ExportAssignment.symbols | 7 + .../reference/es6ExportAssignment.types | 8 + .../reference/es6ExportAssignment2.symbols | 11 + .../reference/es6ExportAssignment2.types | 12 + .../reference/es6ExportEquals.symbols | 7 + .../baselines/reference/es6ExportEquals.types | 7 + .../reference/es6ExportEqualsInterop.symbols | 482 + .../reference/es6ExportEqualsInterop.types | 498 + ...aultBindingFollowedWithNamedImport.symbols | 12 +- ...ultBindingFollowedWithNamedImport1.symbols | 59 + ...faultBindingFollowedWithNamedImport1.types | 60 + ...ndingFollowedWithNamedImport1InEs5.symbols | 59 + ...BindingFollowedWithNamedImport1InEs5.types | 60 + ...FollowedWithNamedImport1WithExport.symbols | 59 + ...ngFollowedWithNamedImport1WithExport.types | 60 + ...tBindingFollowedWithNamedImportDts.symbols | 71 + ...ultBindingFollowedWithNamedImportDts.types | 77 + ...BindingFollowedWithNamedImportDts1.symbols | 59 + ...ltBindingFollowedWithNamedImportDts1.types | 65 + ...indingFollowedWithNamedImportInEs5.symbols | 64 + ...tBindingFollowedWithNamedImportInEs5.types | 65 + ...gFollowedWithNamedImportWithExport.symbols | 66 + ...ingFollowedWithNamedImportWithExport.types | 68 + ...indingFollowedWithNamespaceBinding.symbols | 15 + ...tBindingFollowedWithNamespaceBinding.types | 16 + ...wedWithNamespaceBinding1WithExport.symbols | 16 + ...lowedWithNamespaceBinding1WithExport.types | 17 + ...ingFollowedWithNamespaceBindingDts.symbols | 15 + ...ndingFollowedWithNamespaceBindingDts.types | 16 + ...gFollowedWithNamespaceBindingInEs5.symbols | 15 + ...ingFollowedWithNamespaceBindingInEs5.types | 16 + ...owedWithNamespaceBindingWithExport.symbols | 15 + ...llowedWithNamespaceBindingWithExport.types | 16 + .../es6ImportDefaultBindingInEs5.symbols | 11 + .../es6ImportDefaultBindingInEs5.types | 12 + ...es6ImportDefaultBindingMergeErrors.symbols | 30 + .../es6ImportDefaultBindingMergeErrors.types | 32 + ...ortDefaultBindingNoDefaultProperty.symbols | 8 + ...mportDefaultBindingNoDefaultProperty.types | 9 + .../es6ImportDefaultBindingWithExport.symbols | 18 + .../es6ImportDefaultBindingWithExport.types | 19 + .../es6ImportEqualsDeclaration.symbols | 11 + .../es6ImportEqualsDeclaration.types | 12 + ...s6ImportNameSpaceImportMergeErrors.symbols | 23 + .../es6ImportNameSpaceImportMergeErrors.types | 25 + ...es6ImportNameSpaceImportWithExport.symbols | 17 + .../es6ImportNameSpaceImportWithExport.types | 18 + .../reference/es6ImportNamedImport.symbols | 20 +- .../reference/es6ImportNamedImportAmd.symbols | 20 +- ...mportNamedImportIdentifiersParsing.symbols | 19 + ...6ImportNamedImportIdentifiersParsing.types | 19 + .../es6ImportNamedImportInEs5.symbols | 20 +- .../es6ImportNamedImportMergeErrors.symbols | 50 + .../es6ImportNamedImportMergeErrors.types | 53 + ...es6ImportNamedImportNoExportMember.symbols | 16 + .../es6ImportNamedImportNoExportMember.types | 17 + ...es6ImportNamedImportNoNamedExports.symbols | 15 + .../es6ImportNamedImportNoNamedExports.types | 16 + .../es6ImportNamedImportParsingError.symbols | 23 + .../es6ImportNamedImportParsingError.types | 36 + .../es6ImportNamedImportWithExport.symbols | 121 + .../es6ImportNamedImportWithExport.types | 127 + .../reference/es6ImportParseErrors.symbols | 3 + .../reference/es6ImportParseErrors.types | 4 + ...6ImportWithoutFromClauseWithExport.symbols | 7 + ...es6ImportWithoutFromClauseWithExport.types | 8 + .../reference/es6MemberScoping.symbols | 27 + .../reference/es6MemberScoping.types | 31 + .../es6ModuleInternalNamedImports.symbols | 76 + .../es6ModuleInternalNamedImports.types | 77 + .../es6ModuleInternalNamedImports2.symbols | 80 + .../es6ModuleInternalNamedImports2.types | 81 + .../es6modulekindWithES5Target10.symbols | 11 + .../es6modulekindWithES5Target10.types | 11 + .../es6modulekindWithES5Target9.symbols | 27 + .../es6modulekindWithES5Target9.types | 27 + .../esnextmodulekindWithES5Target10.symbols | 11 + .../esnextmodulekindWithES5Target10.types | 11 + .../esnextmodulekindWithES5Target9.symbols | 27 + .../esnextmodulekindWithES5Target9.types | 27 + tests/baselines/reference/evalAfter0.symbols | 10 + tests/baselines/reference/evalAfter0.types | 20 + ...ithAnnotationAndInvalidInitializer.symbols | 155 + ...eWithAnnotationAndInvalidInitializer.types | 173 + .../reference/exactSpellingSuggestion.symbols | 19 + .../reference/exactSpellingSuggestion.types | 30 + ...excessPropertyCheckWithEmptyObject.symbols | 32 + .../excessPropertyCheckWithEmptyObject.types | 42 + .../excessPropertyCheckWithSpread.symbols | 47 + .../excessPropertyCheckWithSpread.types | 53 + ...xcessPropertyErrorForFunctionTypes.symbols | 17 + .../excessPropertyErrorForFunctionTypes.types | 21 + ...orInTemplateStringWithSyntaxError1.symbols | 138 + ...atorInTemplateStringWithSyntaxError1.types | 273 + ...orInTemplateStringWithSyntaxError2.symbols | 138 + ...atorInTemplateStringWithSyntaxError2.types | 273 + ...orInTemplateStringWithSyntaxError3.symbols | 138 + ...atorInTemplateStringWithSyntaxError3.types | 273 + ...exponentiationOperatorSyntaxError1.symbols | 86 + .../exponentiationOperatorSyntaxError1.types | 248 + ...exponentiationOperatorSyntaxError2.symbols | 149 + .../exponentiationOperatorSyntaxError2.types | 416 + ...tiationOperatorWithInvalidOperands.symbols | 295 + ...entiationOperatorWithInvalidOperands.types | 343 + ...validSimpleUnaryExpressionOperands.symbols | 81 + ...InvalidSimpleUnaryExpressionOperands.types | 253 + .../exponentiationOperatorWithNew.symbols | 25 + .../exponentiationOperatorWithNew.types | 36 + ...torWithNullValueAndInvalidOperands.symbols | 57 + ...ratorWithNullValueAndInvalidOperands.types | 87 + ...rWithOnlyNullValueOrUndefinedValue.symbols | 18 + ...torWithOnlyNullValueOrUndefinedValue.types | 26 + ...nOperatorWithTemplateStringInvalid.symbols | 42 + ...ionOperatorWithTemplateStringInvalid.types | 87 + ...eratorWithTemplateStringInvalidES6.symbols | 38 + ...OperatorWithTemplateStringInvalidES6.types | 85 + ...entiationOperatorWithTypeParameter.symbols | 78 + ...onentiationOperatorWithTypeParameter.types | 89 + ...thUndefinedValueAndInvalidOperands.symbols | 69 + ...WithUndefinedValueAndInvalidOperands.types | 87 + .../reference/exportAlreadySeen.symbols | 40 + .../reference/exportAlreadySeen.types | 41 + .../exportAssignNonIdentifier.symbols | 34 + .../reference/exportAssignNonIdentifier.types | 41 + .../exportAssignmentAndDeclaration.symbols | 19 + .../exportAssignmentAndDeclaration.types | 19 + ...rtAssignmentConstrainedGenericType.symbols | 41 + ...portAssignmentConstrainedGenericType.types | 47 + ...AssignmentOfDeclaredExternalModule.symbols | 33 + ...rtAssignmentOfDeclaredExternalModule.types | 39 + ...nmentWithDeclareAndExportModifiers.symbols | 7 + ...ignmentWithDeclareAndExportModifiers.types | 7 + ...xportAssignmentWithDeclareModifier.symbols | 7 + .../exportAssignmentWithDeclareModifier.types | 7 + ...exportAssignmentWithExportModifier.symbols | 7 + .../exportAssignmentWithExportModifier.types | 7 + .../exportAssignmentWithExports.symbols | 10 + .../exportAssignmentWithExports.types | 10 + .../baselines/reference/exportBinding.symbols | 33 +- tests/baselines/reference/exportBinding.types | 24 +- .../reference/exportClassWithoutName.symbols | 4 + .../reference/exportClassWithoutName.types | 4 + .../exportDeclarationInInternalModule.symbols | 30 + .../exportDeclarationInInternalModule.types | 31 + ...rtDeclarationsInAmbientNamespaces2.symbols | 14 + ...portDeclarationsInAmbientNamespaces2.types | 14 + .../reference/exportDeclareClass1.symbols | 24 + .../reference/exportDeclareClass1.types | 24 + .../reference/exportDefaultInJsFile01.symbols | 3 + .../reference/exportDefaultInJsFile01.types | 3 + .../reference/exportDefaultInJsFile02.symbols | 3 + .../reference/exportDefaultInJsFile02.types | 3 + .../reference/exportEqualErrorType.symbols | 48 + .../reference/exportEqualErrorType.types | 54 + .../exportEqualMemberMissing.symbols | 48 + .../reference/exportEqualMemberMissing.types | 54 + ...xportEqualsClassRedeclarationError.symbols | 21 + .../exportEqualsClassRedeclarationError.types | 22 + .../reference/exportInFunction.symbols | 6 + .../reference/exportInFunction.types | 6 + .../exportNonInitializedVariablesAMD.symbols | 90 + .../exportNonInitializedVariablesAMD.types | 104 + ...ortNonInitializedVariablesCommonJS.symbols | 90 + ...xportNonInitializedVariablesCommonJS.types | 104 + .../exportNonInitializedVariablesES6.symbols | 90 + .../exportNonInitializedVariablesES6.types | 104 + ...xportNonInitializedVariablesSystem.symbols | 90 + .../exportNonInitializedVariablesSystem.types | 104 + .../exportNonInitializedVariablesUMD.symbols | 90 + .../exportNonInitializedVariablesUMD.types | 104 + .../reference/exportSameNameFuncVar.symbols | 7 + .../reference/exportSameNameFuncVar.types | 8 + ...SpecifierAndLocalMemberDeclaration.symbols | 25 + ...rtSpecifierAndLocalMemberDeclaration.types | 27 + .../exportSpecifierForAGlobal.symbols | 19 + .../reference/exportSpecifierForAGlobal.types | 19 + ...cifierReferencingOuterDeclaration1.symbols | 14 + ...pecifierReferencingOuterDeclaration1.types | 14 + ...cifierReferencingOuterDeclaration2.symbols | 14 + ...pecifierReferencingOuterDeclaration2.types | 14 + ...cifierReferencingOuterDeclaration3.symbols | 22 + ...pecifierReferencingOuterDeclaration3.types | 23 + ...cifierReferencingOuterDeclaration4.symbols | 22 + ...pecifierReferencingOuterDeclaration4.types | 23 + .../reference/exportStar-amd.symbols | 55 + .../baselines/reference/exportStar-amd.types | 60 + tests/baselines/reference/exportStar.symbols | 55 + tests/baselines/reference/exportStar.types | 60 + .../exportStarFromEmptyModule.symbols | 43 + .../reference/exportStarFromEmptyModule.types | 45 + .../exportedBlockScopedDeclarations.symbols | 46 + .../exportedBlockScopedDeclarations.types | 46 + .../exportingContainingVisibleType.symbols | 20 + .../exportingContainingVisibleType.types | 21 + ...mportsWithContextualKeywordNames01.symbols | 29 + ...dImportsWithContextualKeywordNames01.types | 31 + .../exportsAndImportsWithUnderscores1.symbols | 22 + .../exportsAndImportsWithUnderscores1.types | 29 + tests/baselines/reference/expr.symbols | 804 + tests/baselines/reference/expr.types | 1002 + .../expressionTypeNodeShouldError.symbols | 105 + .../expressionTypeNodeShouldError.types | 148 + .../baselines/reference/extBaseClass2.symbols | 18 + tests/baselines/reference/extBaseClass2.types | 21 + ...extendAndImplementTheSameBaseType2.symbols | 53 + .../extendAndImplementTheSameBaseType2.types | 57 + tests/baselines/reference/extendArray.symbols | 67 + tests/baselines/reference/extendArray.types | 99 + .../extendBaseClassBeforeItsDeclared.symbols | 9 + .../extendBaseClassBeforeItsDeclared.types | 9 + .../baselines/reference/extendFromAny.symbols | 35 + tests/baselines/reference/extendFromAny.types | 50 + .../reference/extendGenericArray.symbols | 19 + .../reference/extendGenericArray.types | 21 + .../reference/extendGenericArray2.symbols | 25 + .../reference/extendGenericArray2.types | 26 + .../reference/extendNonClassSymbol2.symbols | 14 + .../reference/extendNonClassSymbol2.types | 20 + .../extendPrivateConstructorClass.symbols | 18 + .../extendPrivateConstructorClass.types | 18 + ...erfacesWithDuplicateTypeParameters.symbols | 26 + ...nterfacesWithDuplicateTypeParameters.types | 26 + .../extendsClauseAlreadySeen.symbols | 13 + .../reference/extendsClauseAlreadySeen.types | 13 + .../extendsClauseAlreadySeen2.symbols | 15 + .../reference/extendsClauseAlreadySeen2.types | 15 + .../reference/extendsUntypedModule.symbols | 11 + .../reference/extendsUntypedModule.types | 11 + tests/baselines/reference/extension.symbols | 66 + tests/baselines/reference/extension.types | 70 + .../baselines/reference/externModule.symbols | 136 + tests/baselines/reference/externModule.types | 165 + .../reference/externSemantics.symbols | 10 + .../baselines/reference/externSemantics.types | 12 + .../baselines/reference/externSyntax.symbols | 27 + tests/baselines/reference/externSyntax.types | 27 + ...xternalModuleExportingGenericClass.symbols | 33 + .../externalModuleExportingGenericClass.types | 37 + .../externalModuleImmutableBindings.symbols | 142 + .../externalModuleImmutableBindings.types | 232 + ...ResolutionOrderInImportDeclaration.symbols | 25 + ...ceResolutionOrderInImportDeclaration.types | 29 + .../reference/fallFromLastCase2.symbols | 49 + .../reference/fallFromLastCase2.types | 71 + .../reference/fatarrowfunctionsErrors.symbols | 37 + .../reference/fatarrowfunctionsErrors.types | 68 + .../fatarrowfunctionsOptionalArgs.symbols | 316 + .../fatarrowfunctionsOptionalArgs.types | 699 + ...tarrowfunctionsOptionalArgsErrors1.symbols | 19 + ...fatarrowfunctionsOptionalArgsErrors1.types | 31 + ...tarrowfunctionsOptionalArgsErrors2.symbols | 10 + ...fatarrowfunctionsOptionalArgsErrors2.types | 38 + ...tarrowfunctionsOptionalArgsErrors3.symbols | 4 + ...fatarrowfunctionsOptionalArgsErrors3.types | 6 + ...tarrowfunctionsOptionalArgsErrors4.symbols | 63 + ...fatarrowfunctionsOptionalArgsErrors4.types | 134 + .../fieldAndGetterWithSameName.symbols | 10 + .../fieldAndGetterWithSameName.types | 11 + .../reference/fileWithNextLine3.symbols | 5 + .../reference/fileWithNextLine3.types | 6 + .../filesEmittingIntoSameOutput.symbols | 10 + .../filesEmittingIntoSameOutput.types | 10 + ...nMissingTypeArgsOnJSConstructCalls.symbols | 56 + ...lInMissingTypeArgsOnJSConstructCalls.types | 60 + .../reference/fixSignatureCaching.symbols | 1584 + .../reference/fixSignatureCaching.types | 3282 + ...meterInSignatureWithRestParameters.symbols | 12 + ...rameterInSignatureWithRestParameters.types | 15 + .../fixingTypeParametersRepeatedly2.symbols | 73 + .../fixingTypeParametersRepeatedly2.types | 79 + .../reference/for-inStatements.symbols | 231 + .../reference/for-inStatements.types | 268 + .../for-inStatementsArrayErrors.symbols | 43 + .../for-inStatementsArrayErrors.types | 53 + .../for-inStatementsDestructuring.symbols | 5 + .../for-inStatementsDestructuring.types | 6 + .../for-inStatementsDestructuring2.symbols | 5 + .../for-inStatementsDestructuring2.types | 6 + .../for-inStatementsDestructuring3.symbols | 9 + .../for-inStatementsDestructuring3.types | 11 + .../for-inStatementsDestructuring4.symbols | 9 + .../for-inStatementsDestructuring4.types | 11 + .../reference/for-inStatementsInvalid.symbols | 185 + .../reference/for-inStatementsInvalid.types | 215 + tests/baselines/reference/for-of10.symbols | 7 + tests/baselines/reference/for-of10.types | 9 + tests/baselines/reference/for-of11.symbols | 7 + tests/baselines/reference/for-of11.types | 10 + tests/baselines/reference/for-of12.symbols | 9 + tests/baselines/reference/for-of12.types | 13 + tests/baselines/reference/for-of14.symbols | 18 + tests/baselines/reference/for-of14.types | 20 + tests/baselines/reference/for-of15.symbols | 26 + tests/baselines/reference/for-of15.types | 28 + tests/baselines/reference/for-of16.symbols | 21 + tests/baselines/reference/for-of16.types | 22 + tests/baselines/reference/for-of17.symbols | 33 + tests/baselines/reference/for-of17.types | 38 + tests/baselines/reference/for-of2.symbols | 7 + tests/baselines/reference/for-of2.types | 8 + tests/baselines/reference/for-of29.symbols | 16 + tests/baselines/reference/for-of29.types | 16 + tests/baselines/reference/for-of3.symbols | 7 + tests/baselines/reference/for-of3.types | 9 + tests/baselines/reference/for-of30.symbols | 33 + tests/baselines/reference/for-of30.types | 39 + tests/baselines/reference/for-of31.symbols | 28 + tests/baselines/reference/for-of31.types | 32 + tests/baselines/reference/for-of32.symbols | 5 + tests/baselines/reference/for-of32.types | 5 + tests/baselines/reference/for-of33.symbols | 18 + tests/baselines/reference/for-of33.types | 19 + tests/baselines/reference/for-of34.symbols | 25 + tests/baselines/reference/for-of34.types | 26 + tests/baselines/reference/for-of35.symbols | 31 + tests/baselines/reference/for-of35.types | 35 + tests/baselines/reference/for-of39.symbols | 16 + tests/baselines/reference/for-of39.types | 24 + tests/baselines/reference/for-of46.symbols | 20 + tests/baselines/reference/for-of46.types | 30 + tests/baselines/reference/for-of47.symbols | 29 + tests/baselines/reference/for-of47.types | 35 + tests/baselines/reference/for-of48.symbols | 28 + tests/baselines/reference/for-of48.types | 33 + tests/baselines/reference/for-of49.symbols | 20 + tests/baselines/reference/for-of49.types | 28 + tests/baselines/reference/for-of51.symbols | 4 + tests/baselines/reference/for-of51.types | 5 + tests/baselines/reference/for-of52.symbols | 5 + tests/baselines/reference/for-of52.types | 7 + tests/baselines/reference/for-of54.symbols | 7 + tests/baselines/reference/for-of54.types | 9 + tests/baselines/reference/for-of55.symbols | 11 + tests/baselines/reference/for-of55.types | 13 + tests/baselines/reference/for-of6.symbols | 5 + tests/baselines/reference/for-of6.types | 9 + tests/baselines/reference/for-of7.symbols | 5 + tests/baselines/reference/for-of7.types | 9 + tests/baselines/reference/for.symbols | 57 + tests/baselines/reference/for.types | 80 + tests/baselines/reference/forIn.symbols | 60 + tests/baselines/reference/forIn.types | 72 + tests/baselines/reference/forIn2.symbols | 4 + tests/baselines/reference/forIn2.types | 5 + .../reference/forInBreakStatements.symbols | 22 +- .../reference/forInContinueStatements.symbols | 22 +- .../reference/forInStatement2.symbols | 8 + .../baselines/reference/forInStatement2.types | 8 + .../reference/forInStatement4.symbols | 8 + .../baselines/reference/forInStatement4.types | 8 + .../reference/forInStatement7.symbols | 11 + .../baselines/reference/forInStatement7.types | 11 + .../forStatementsMultipleInvalidDecl.symbols | 142 + .../forStatementsMultipleInvalidDecl.types | 164 + .../forStatementsMultipleValidDecl.symbols | 44 +- .../baselines/reference/forgottenNew.symbols | 14 + tests/baselines/reference/forgottenNew.types | 15 + .../forwardRefInClassProperties.symbols | 34 + .../forwardRefInClassProperties.types | 37 + .../reference/forwardRefInEnum.symbols | 35 + .../reference/forwardRefInEnum.types | 38 + tests/baselines/reference/funClodule.symbols | 39 + tests/baselines/reference/funClodule.types | 39 + .../functionAndImportNameConflict.symbols | 12 + .../functionAndImportNameConflict.types | 12 + ...tionAndInterfaceWithSeparateErrors.symbols | 18 + ...nctionAndInterfaceWithSeparateErrors.types | 18 + .../functionAndPropertyNameConflict.symbols | 13 + .../functionAndPropertyNameConflict.types | 14 + .../reference/functionArgShadowing.symbols | 37 + .../reference/functionArgShadowing.types | 41 + .../reference/functionAssignment.symbols | 97 + .../reference/functionAssignment.types | 116 + .../reference/functionCall10.symbols | 17 + .../baselines/reference/functionCall10.types | 26 + .../reference/functionCall11.symbols | 21 + .../baselines/reference/functionCall11.types | 34 + .../reference/functionCall12.symbols | 25 + .../baselines/reference/functionCall12.types | 42 + .../reference/functionCall13.symbols | 21 + .../baselines/reference/functionCall13.types | 34 + .../reference/functionCall14.symbols | 21 + .../baselines/reference/functionCall14.types | 34 + .../reference/functionCall15.symbols | 7 + .../baselines/reference/functionCall15.types | 7 + .../reference/functionCall16.symbols | 25 + .../baselines/reference/functionCall16.types | 41 + .../reference/functionCall17.symbols | 26 + .../baselines/reference/functionCall17.types | 44 + .../baselines/reference/functionCall6.symbols | 17 + tests/baselines/reference/functionCall6.types | 25 + .../baselines/reference/functionCall7.symbols | 36 + tests/baselines/reference/functionCall7.types | 44 + .../baselines/reference/functionCall8.symbols | 17 + tests/baselines/reference/functionCall8.types | 25 + .../baselines/reference/functionCall9.symbols | 21 + tests/baselines/reference/functionCall9.types | 34 + .../baselines/reference/functionCalls.symbols | 72 + tests/baselines/reference/functionCalls.types | 96 + .../functionConstraintSatisfaction2.symbols | 140 + .../functionConstraintSatisfaction2.types | 163 + ...unctionExpressionContextualTyping2.symbols | 25 + .../functionExpressionContextualTyping2.types | 28 + .../functionExpressionInWithBlock.symbols | 10 + .../functionExpressionInWithBlock.types | 16 + ...functionExpressionShadowedByParams.symbols | 33 + .../functionExpressionShadowedByParams.types | 46 + .../functionImplementationErrors.symbols | 149 + .../functionImplementationErrors.types | 192 + .../reference/functionImplementations.symbols | 26 +- ...functionLikeInParameterInitializer.symbols | 42 + .../functionLikeInParameterInitializer.types | 50 + .../reference/functionNameConflicts.symbols | 50 + .../reference/functionNameConflicts.types | 50 + .../functionOverloadAmbiguity1.symbols | 41 + .../functionOverloadAmbiguity1.types | 47 + ...ionOverloadCompatibilityWithVoid01.symbols | 11 + ...ctionOverloadCompatibilityWithVoid01.types | 11 + .../reference/functionOverloadErrors.symbols | 285 + .../reference/functionOverloadErrors.types | 292 + .../functionOverloadErrorsSyntax.symbols | 29 + .../functionOverloadErrorsSyntax.types | 29 + ...nOverloadImplementationOfWrongName.symbols | 13 + ...ionOverloadImplementationOfWrongName.types | 13 + ...OverloadImplementationOfWrongName2.symbols | 13 + ...onOverloadImplementationOfWrongName2.types | 13 + .../reference/functionOverloads.symbols | 16 + .../reference/functionOverloads.types | 19 + .../reference/functionOverloads1.symbols | 8 + .../reference/functionOverloads1.types | 13 + .../reference/functionOverloads11.symbols | 7 + .../reference/functionOverloads11.types | 8 + .../reference/functionOverloads17.symbols | 10 + .../reference/functionOverloads17.types | 12 + .../reference/functionOverloads18.symbols | 12 + .../reference/functionOverloads18.types | 14 + .../reference/functionOverloads19.symbols | 17 + .../reference/functionOverloads19.types | 19 + .../reference/functionOverloads2.symbols | 18 + .../reference/functionOverloads2.types | 20 + .../reference/functionOverloads20.symbols | 16 + .../reference/functionOverloads20.types | 17 + .../reference/functionOverloads27.symbols | 16 + .../reference/functionOverloads27.types | 19 + .../reference/functionOverloads29.symbols | 18 + .../reference/functionOverloads29.types | 19 + .../reference/functionOverloads3.symbols | 4 + .../reference/functionOverloads3.types | 4 + .../reference/functionOverloads34.symbols | 21 + .../reference/functionOverloads34.types | 22 + .../reference/functionOverloads37.symbols | 21 + .../reference/functionOverloads37.types | 22 + .../reference/functionOverloads4.symbols | 7 + .../reference/functionOverloads4.types | 8 + .../reference/functionOverloads40.symbols | 22 + .../reference/functionOverloads40.types | 26 + .../reference/functionOverloads41.symbols | 21 + .../reference/functionOverloads41.types | 24 + .../reference/functionOverloads5.symbols | 12 + .../reference/functionOverloads5.types | 12 + .../functionOverloadsOutOfOrder.symbols | 38 + .../functionOverloadsOutOfOrder.types | 44 + ...functionSignatureAssignmentCompat1.symbols | 45 + .../functionSignatureAssignmentCompat1.types | 46 + ...nctionTypeArgumentAssignmentCompat.symbols | 33 + ...functionTypeArgumentAssignmentCompat.types | 43 + .../functionTypesLackingReturnTypes.symbols | 19 + .../functionTypesLackingReturnTypes.types | 21 + ...tionVariableInReturnTypeAnnotation.symbols | 10 + ...nctionVariableInReturnTypeAnnotation.types | 12 + ...hDefaultParameterWithNoStatements9.symbols | 9 + ...ithDefaultParameterWithNoStatements9.types | 15 + .../functionWithSameNameAsField.symbols | 22 + .../functionWithSameNameAsField.types | 23 + ...singReturnStatementsAndExpressions.symbols | 193 + ...issingReturnStatementsAndExpressions.types | 206 + .../functionsWithModifiersInBlocks1.symbols | 11 + .../functionsWithModifiersInBlocks1.types | 11 + .../reference/funduleSplitAcrossFiles.symbols | 16 + .../reference/funduleSplitAcrossFiles.types | 17 + tests/baselines/reference/fuzzy.symbols | 70 + tests/baselines/reference/fuzzy.types | 79 + .../reference/generatorES6_5.symbols | 6 + .../baselines/reference/generatorES6_5.types | 11 + .../generatorInAmbientContext1.symbols | 7 + .../generatorInAmbientContext1.types | 7 + .../generatorInAmbientContext2.symbols | 7 + .../generatorInAmbientContext2.types | 7 + .../generatorInAmbientContext3.d.symbols | 7 + .../generatorInAmbientContext3.d.types | 7 + .../generatorInAmbientContext4.d.symbols | 7 + .../generatorInAmbientContext4.d.types | 7 + .../reference/generatorOverloads1.symbols | 19 + .../reference/generatorOverloads1.types | 19 + .../reference/generatorOverloads2.symbols | 19 + .../reference/generatorOverloads2.types | 19 + .../reference/generatorOverloads3.symbols | 19 + .../reference/generatorOverloads3.types | 19 + .../reference/generatorTypeCheck18.symbols | 18 + .../reference/generatorTypeCheck18.types | 22 + .../reference/generatorTypeCheck20.symbols | 18 + .../reference/generatorTypeCheck20.types | 23 + .../reference/generatorTypeCheck21.symbols | 19 + .../reference/generatorTypeCheck21.types | 23 + .../reference/generatorTypeCheck25.symbols | 32 + .../reference/generatorTypeCheck25.types | 45 + .../reference/generatorTypeCheck31.symbols | 14 + .../reference/generatorTypeCheck31.types | 22 + .../reference/generatorTypeCheck32.symbols | 8 + .../reference/generatorTypeCheck32.types | 10 + .../reference/generatorTypeCheck39.symbols | 21 + .../reference/generatorTypeCheck39.types | 27 + .../reference/generatorTypeCheck40.symbols | 7 + .../reference/generatorTypeCheck40.types | 10 + .../reference/generatorTypeCheck47.symbols | 4 + .../reference/generatorTypeCheck47.types | 4 + .../reference/generatorTypeCheck48.symbols | 6 + .../reference/generatorTypeCheck48.types | 7 + .../reference/generatorTypeCheck51.symbols | 10 + .../reference/generatorTypeCheck51.types | 12 + .../reference/generatorTypeCheck55.symbols | 8 + .../reference/generatorTypeCheck55.types | 11 + .../reference/generatorTypeCheck56.symbols | 13 + .../reference/generatorTypeCheck56.types | 19 + .../reference/generatorTypeCheck57.symbols | 12 + .../reference/generatorTypeCheck57.types | 14 + .../reference/generatorTypeCheck58.symbols | 12 + .../reference/generatorTypeCheck58.types | 14 + .../reference/generatorTypeCheck59.symbols | 13 + .../reference/generatorTypeCheck59.types | 17 + .../reference/generatorTypeCheck6.symbols | 4 + .../reference/generatorTypeCheck6.types | 4 + .../reference/generatorTypeCheck60.symbols | 7 + .../reference/generatorTypeCheck60.types | 9 + .../reference/generatorTypeCheck61.symbols | 8 + .../reference/generatorTypeCheck61.types | 12 + .../reference/generatorTypeCheck63.symbols | 113 + .../reference/generatorTypeCheck63.types | 137 + .../reference/generatorTypeCheck7.symbols | 12 + .../reference/generatorTypeCheck7.types | 12 + .../reference/generatorTypeCheck8.symbols | 10 + .../reference/generatorTypeCheck8.types | 10 + .../reference/generatorTypeCheck9.symbols | 4 + .../reference/generatorTypeCheck9.types | 4 + ...icAndNonGenericInheritedSignature1.symbols | 24 + ...ericAndNonGenericInheritedSignature1.types | 24 + ...icAndNonGenericInheritedSignature2.symbols | 24 + ...ericAndNonGenericInheritedSignature2.types | 24 + ...NonGenericInterfaceWithTheSameName.symbols | 86 + ...ndNonGenericInterfaceWithTheSameName.types | 86 + ...nericArgumentCallSigAssignmentCompat.types | 4 +- .../reference/genericArrayAssignment1.symbols | 11 + .../reference/genericArrayAssignment1.types | 12 + ...genericArrayAssignmentCompatErrors.symbols | 68 + .../genericArrayAssignmentCompatErrors.types | 85 + .../reference/genericArrayExtenstions.symbols | 22 + .../reference/genericArrayExtenstions.types | 22 + .../reference/genericArrayMethods1.symbols | 6 + .../reference/genericArrayMethods1.types | 11 + .../genericArrayWithoutTypeAnnotation.symbols | 15 + .../genericArrayWithoutTypeAnnotation.types | 15 + ...ricAssignmentCompatWithInterfaces1.symbols | 73 + ...nericAssignmentCompatWithInterfaces1.types | 83 + .../genericCallSpecializedToTypeArg.symbols | 30 + .../genericCallSpecializedToTypeArg.types | 34 + ...oadedMethodWithOverloadedArguments.symbols | 328 + ...rloadedMethodWithOverloadedArguments.types | 334 + ...hConstraintsTypeArgumentInference2.symbols | 45 + ...ithConstraintsTypeArgumentInference2.types | 55 + ...CallWithConstructorTypedArguments5.symbols | 100 + ...icCallWithConstructorTypedArguments5.types | 111 + ...ericCallWithFunctionTypedArguments.symbols | 142 + ...enericCallWithFunctionTypedArguments.types | 205 + ...ricCallWithFunctionTypedArguments2.symbols | 146 + ...nericCallWithFunctionTypedArguments2.types | 174 + ...ricCallWithFunctionTypedArguments5.symbols | 92 + ...nericCallWithFunctionTypedArguments5.types | 122 + ...CallWithGenericSignatureArguments2.symbols | 317 + ...icCallWithGenericSignatureArguments2.types | 361 + ...CallWithGenericSignatureArguments3.symbols | 163 + ...icCallWithGenericSignatureArguments3.types | 232 + .../genericCallWithObjectLiteralArgs.symbols | 41 + .../genericCallWithObjectLiteralArgs.types | 55 + ...ricCallWithObjectLiteralArguments1.symbols | 44 + ...nericCallWithObjectLiteralArguments1.types | 69 + .../genericCallWithObjectTypeArgs.symbols | 64 + .../genericCallWithObjectTypeArgs.types | 68 + ...lWithObjectTypeArgsAndConstraints3.symbols | 123 + ...allWithObjectTypeArgsAndConstraints3.types | 146 + ...lWithObjectTypeArgsAndConstraints4.symbols | 110 + ...allWithObjectTypeArgsAndConstraints4.types | 137 + ...lWithObjectTypeArgsAndConstraints5.symbols | 69 + ...allWithObjectTypeArgsAndConstraints5.types | 76 + ...lWithObjectTypeArgsAndInitializers.symbols | 75 + ...allWithObjectTypeArgsAndInitializers.types | 77 + ...erloadedConstructorTypedArguments2.symbols | 132 + ...OverloadedConstructorTypedArguments2.types | 139 + ...hOverloadedFunctionTypedArguments2.symbols | 125 + ...ithOverloadedFunctionTypedArguments2.types | 137 + .../genericCallWithTupleType.symbols | 99 + .../reference/genericCallWithTupleType.types | 147 + .../reference/genericCallWithoutArgs.symbols | 14 + .../reference/genericCallWithoutArgs.types | 15 + ...nvokedInsideItsContainingFunction1.symbols | 66 + ...kInvokedInsideItsContainingFunction1.types | 86 + .../genericCallsWithoutParens.symbols | 22 + .../reference/genericCallsWithoutParens.types | 24 + .../reference/genericChainedCalls.symbols | 72 + .../reference/genericChainedCalls.types | 92 + ...ritsConstructorFromNonGenericClass.symbols | 16 + ...heritsConstructorFromNonGenericClass.types | 16 + ...ssWithFunctionTypedMemberArguments.symbols | 260 + ...lassWithFunctionTypedMemberArguments.types | 329 + ...ClassWithStaticsUsingTypeArguments.symbols | 37 + ...icClassWithStaticsUsingTypeArguments.types | 56 + .../genericClassesRedeclaration.symbols | 382 + .../genericClassesRedeclaration.types | 382 + .../reference/genericCloduleInModule2.symbols | 35 + .../reference/genericCloduleInModule2.types | 39 + .../reference/genericCloneReturnTypes.symbols | 59 + .../reference/genericCloneReturnTypes.types | 64 + .../genericCloneReturnTypes2.symbols | 67 + .../reference/genericCloneReturnTypes2.types | 74 + .../reference/genericCombinators2.symbols | 100 + .../reference/genericCombinators2.types | 106 + .../reference/genericConstraint1.symbols | 28 + .../reference/genericConstraint1.types | 33 + .../reference/genericConstraint2.symbols | 65 + .../reference/genericConstraint2.types | 83 + .../genericConstraintSatisfaction1.symbols | 24 + .../genericConstraintSatisfaction1.types | 27 + ...ericConstructExpressionWithoutArgs.symbols | 25 + ...enericConstructExpressionWithoutArgs.types | 28 + ...icConstructInvocationWithNoTypeArg.symbols | 14 + ...ericConstructInvocationWithNoTypeArg.types | 17 + .../genericConstructorFunction1.symbols | 60 + .../genericConstructorFunction1.types | 68 + .../reference/genericDefaultsErrors.symbols | 138 + .../reference/genericDefaultsErrors.types | 147 + ...ericDerivedTypeWithSpecializedBase.symbols | 32 + ...enericDerivedTypeWithSpecializedBase.types | 33 + ...ricDerivedTypeWithSpecializedBase2.symbols | 35 + ...nericDerivedTypeWithSpecializedBase2.types | 36 + ...ionCallSignatureReturnTypeMismatch.symbols | 30 + ...ctionCallSignatureReturnTypeMismatch.types | 38 + ...ericFunctionTypedArgumentsAreFixed.symbols | 18 + ...enericFunctionTypedArgumentsAreFixed.types | 24 + ...icFunctionsWithOptionalParameters2.symbols | 46 + ...ericFunctionsWithOptionalParameters2.types | 56 + .../reference/genericFunduleInModule.symbols | 28 + .../reference/genericFunduleInModule.types | 32 + .../reference/genericFunduleInModule2.symbols | 32 + .../reference/genericFunduleInModule2.types | 36 + .../baselines/reference/genericGetter.symbols | 30 + tests/baselines/reference/genericGetter.types | 31 + .../reference/genericGetter2.symbols | 24 + .../baselines/reference/genericGetter2.types | 24 + .../reference/genericGetter3.symbols | 36 + .../baselines/reference/genericGetter3.types | 37 + ...ericInterfacesWithoutTypeArguments.symbols | 18 + ...enericInterfacesWithoutTypeArguments.types | 18 + ...enericLambaArgWithoutTypeArguments.symbols | 21 + .../genericLambaArgWithoutTypeArguments.types | 26 + .../reference/genericMemberFunction.symbols | 95 + .../reference/genericMemberFunction.types | 119 + ...ergedDeclarationUsingTypeParameter.symbols | 22 + ...cMergedDeclarationUsingTypeParameter.types | 26 + ...rgedDeclarationUsingTypeParameter2.symbols | 17 + ...MergedDeclarationUsingTypeParameter2.types | 21 + .../reference/genericNewInterface.symbols | 33 + .../reference/genericNewInterface.types | 37 + ...nericObjectCreationWithoutTypeArgs.symbols | 23 + ...genericObjectCreationWithoutTypeArgs.types | 27 + ...ecursiveImplicitConstructorErrors1.symbols | 55 + ...cRecursiveImplicitConstructorErrors1.types | 55 + ...ecursiveImplicitConstructorErrors3.symbols | 121 + ...cRecursiveImplicitConstructorErrors3.types | 152 + .../baselines/reference/genericReduce.symbols | 68 + tests/baselines/reference/genericReduce.types | 103 + .../reference/genericRestArgs.symbols | 53 + .../baselines/reference/genericRestArgs.types | 75 + .../genericReturnTypeFromGetter1.symbols | 26 + .../genericReturnTypeFromGetter1.types | 26 + .../reference/genericSpecializations2.symbols | 49 + .../reference/genericSpecializations2.types | 53 + .../reference/genericSpecializations3.symbols | 90 + .../reference/genericSpecializations3.types | 100 + .../genericTypeArgumentInference1.types | 6 +- .../reference/genericTypeAssertions1.symbols | 25 + .../reference/genericTypeAssertions1.types | 29 + .../reference/genericTypeAssertions2.symbols | 55 + .../reference/genericTypeAssertions2.types | 67 + .../reference/genericTypeAssertions4.symbols | 74 + .../reference/genericTypeAssertions4.types | 86 + .../reference/genericTypeAssertions5.symbols | 74 + .../reference/genericTypeAssertions5.types | 83 + .../reference/genericTypeAssertions6.symbols | 98 + .../reference/genericTypeAssertions6.types | 113 + .../reference/genericTypeConstraints.symbols | 26 + .../reference/genericTypeConstraints.types | 27 + ...TypeReferenceWithoutTypeArgument.d.symbols | 79 + ...icTypeReferenceWithoutTypeArgument.d.types | 81 + ...icTypeReferenceWithoutTypeArgument.symbols | 122 + ...ericTypeReferenceWithoutTypeArgument.types | 128 + ...cTypeReferenceWithoutTypeArgument2.symbols | 117 + ...ricTypeReferenceWithoutTypeArgument2.types | 128 + ...cTypeReferenceWithoutTypeArgument3.symbols | 79 + ...ricTypeReferenceWithoutTypeArgument3.types | 81 + ...nericTypeReferencesRequireTypeArgs.symbols | 35 + ...genericTypeReferencesRequireTypeArgs.types | 36 + ...nericTypeUsedWithoutTypeArguments1.symbols | 10 + ...genericTypeUsedWithoutTypeArguments1.types | 10 + ...nericTypeUsedWithoutTypeArguments3.symbols | 10 + ...genericTypeUsedWithoutTypeArguments3.types | 10 + ...ericTypeWithNonGenericBaseMisMatch.symbols | 30 + ...enericTypeWithNonGenericBaseMisMatch.types | 31 + .../genericWithOpenTypeParameters1.symbols | 60 + .../genericWithOpenTypeParameters1.types | 75 + tests/baselines/reference/generics1.symbols | 67 + tests/baselines/reference/generics1.types | 67 + tests/baselines/reference/generics2.symbols | 79 + tests/baselines/reference/generics2.types | 79 + tests/baselines/reference/generics4.symbols | 29 + tests/baselines/reference/generics4.types | 30 + tests/baselines/reference/generics5.symbols | 31 + tests/baselines/reference/generics5.types | 31 + ...nericsWithDuplicateTypeParameters1.symbols | 78 + ...genericsWithDuplicateTypeParameters1.types | 84 + .../genericsWithoutTypeParameters1.symbols | 106 + .../genericsWithoutTypeParameters1.types | 113 + ...iedReturnTypeAndFunctionClassMerge.symbols | 73 + ...pliedReturnTypeAndFunctionClassMerge.types | 76 + .../reference/getAndSetAsMemberNames.symbols | 47 + .../reference/getAndSetAsMemberNames.types | 54 + .../getAndSetNotIdenticalType.symbols | 13 + .../reference/getAndSetNotIdenticalType.types | 14 + .../getAndSetNotIdenticalType2.symbols | 55 + .../getAndSetNotIdenticalType2.types | 58 + .../getAndSetNotIdenticalType3.symbols | 53 + .../getAndSetNotIdenticalType3.types | 56 + .../getSetAccessorContextualTyping.symbols | 48 + .../getSetAccessorContextualTyping.types | 52 + .../reference/getsetReturnTypes.symbols | 23 + .../reference/getsetReturnTypes.types | 29 + .../getterControlFlowStrictNull.symbols | 35 + .../getterControlFlowStrictNull.types | 45 + .../getterMissingReturnError.symbols | 10 + .../reference/getterMissingReturnError.types | 10 + ...etterThatThrowsShouldNotNeedReturn.symbols | 16 + .../getterThatThrowsShouldNotNeedReturn.types | 18 + .../reference/gettersAndSetters.symbols | 116 + .../reference/gettersAndSetters.types | 139 + .../gettersAndSettersAccessibility.symbols | 12 + .../gettersAndSettersAccessibility.types | 13 + .../reference/gettersAndSettersErrors.symbols | 36 + .../reference/gettersAndSettersErrors.types | 40 + .../gettersAndSettersTypesAgree.symbols | 31 + .../gettersAndSettersTypesAgree.types | 37 + tests/baselines/reference/giant.symbols | 1760 + tests/baselines/reference/giant.types | 1776 + .../reference/grammarAmbiguities.symbols | 40 + .../reference/grammarAmbiguities.types | 55 + .../reference/grammarAmbiguities1.symbols | 45 + .../reference/grammarAmbiguities1.types | 61 + .../heterogeneousArrayAndOverloads.symbols | 40 + .../heterogeneousArrayAndOverloads.types | 57 + tests/baselines/reference/i3.symbols | 21 + tests/baselines/reference/i3.types | 23 + ...SignaturesWithTypeParametersAndAny.symbols | 83 + ...orSignaturesWithTypeParametersAndAny.types | 83 + .../reference/ifElseWithStatements1.symbols | 15 + .../reference/ifElseWithStatements1.types | 27 + .../illegalModifiersOnClassElements.symbols | 10 + .../illegalModifiersOnClassElements.types | 12 + .../illegalSuperCallsInConstructor.symbols | 40 + .../illegalSuperCallsInConstructor.types | 57 + .../implementClausePrecedingExtends.symbols | 10 + .../implementClausePrecedingExtends.types | 10 + ...mplementGenericWithMismatchedTypes.symbols | 53 + .../implementGenericWithMismatchedTypes.types | 55 + .../implementPublicPropertyAsPrivate.symbols | 14 + .../implementPublicPropertyAsPrivate.types | 15 + ...nterfaceExtendingClassWithPrivates.symbols | 50 + ...nInterfaceExtendingClassWithPrivates.types | 50 + ...terfaceExtendingClassWithPrivates2.symbols | 193 + ...InterfaceExtendingClassWithPrivates2.types | 195 + ...erfaceExtendingClassWithProtecteds.symbols | 87 + ...nterfaceExtendingClassWithProtecteds.types | 87 + .../implementsClauseAlreadySeen.symbols | 13 + .../implementsClauseAlreadySeen.types | 13 + .../reference/implicitAnyAmbients.symbols | 63 + .../reference/implicitAnyAmbients.types | 63 + .../reference/implicitAnyCastedValue.symbols | 147 + .../reference/implicitAnyCastedValue.types | 180 + ...clareFunctionExprWithoutFormalType.symbols | 45 + ...DeclareFunctionExprWithoutFormalType.types | 60 + ...nyDeclareFunctionWithoutFormalType.symbols | 38 + ...tAnyDeclareFunctionWithoutFormalType.types | 41 + ...mplicitAnyDeclareMemberWithoutType.symbols | 26 + .../implicitAnyDeclareMemberWithoutType.types | 26 + ...plicitAnyDeclareMemberWithoutType2.symbols | 23 + ...implicitAnyDeclareMemberWithoutType2.types | 24 + ...tAnyDeclareTypePropertyWithoutType.symbols | 49 + ...citAnyDeclareTypePropertyWithoutType.types | 49 + ...DeclareVariablesWithoutTypeAndInit.symbols | 35 + ...nyDeclareVariablesWithoutTypeAndInit.types | 38 + .../implicitAnyFromCircularInference.symbols | 95 + .../implicitAnyFromCircularInference.types | 106 + ...unctionInvocationWithAnyArguements.symbols | 117 + ...yFunctionInvocationWithAnyArguements.types | 148 + ...nOverloadWithImplicitAnyReturnType.symbols | 18 + ...ionOverloadWithImplicitAnyReturnType.types | 18 + ...itAnyFunctionReturnNullOrUndefined.symbols | 47 + ...icitAnyFunctionReturnNullOrUndefined.types | 54 + ...GetAndSetAccessorWithAnyReturnType.symbols | 48 + ...nyGetAndSetAccessorWithAnyReturnType.types | 51 + .../implicitAnyInAmbientDeclaration.symbols | 25 + .../implicitAnyInAmbientDeclaration.types | 25 + ...implicitAnyInAmbientDeclaration2.d.symbols | 36 + .../implicitAnyInAmbientDeclaration2.d.types | 36 + ...AnyNewExprLackConstructorSignature.symbols | 8 + ...itAnyNewExprLackConstructorSignature.types | 14 + .../reference/implicitAnyWidenToAny.symbols | 77 + .../reference/implicitAnyWidenToAny.types | 101 + .../reference/implicitConstParameters.symbols | 136 + .../reference/implicitConstParameters.types | 165 + .../reference/importAliasIdentifiers.symbols | 18 +- .../reference/importAnImport.symbols | 20 + .../baselines/reference/importAnImport.types | 21 + ...ortAndVariableDeclarationConflict1.symbols | 16 + ...mportAndVariableDeclarationConflict1.types | 18 + ...ortAndVariableDeclarationConflict3.symbols | 18 + ...mportAndVariableDeclarationConflict3.types | 19 + ...ortAndVariableDeclarationConflict4.symbols | 16 + ...mportAndVariableDeclarationConflict4.types | 18 + .../reference/importAsBaseClass.symbols | 16 + .../reference/importAsBaseClass.types | 17 + .../importCallExpression5ESNext.symbols | 39 + .../importCallExpression5ESNext.types | 54 + .../importCallExpression6ESNext.symbols | 39 + .../importCallExpression6ESNext.types | 54 + ...portCallExpressionCheckReturntype1.symbols | 32 + ...importCallExpressionCheckReturntype1.types | 36 + ...portCallExpressionDeclarationEmit2.symbols | 9 + ...importCallExpressionDeclarationEmit2.types | 11 + .../importCallExpressionErrorInES2015.symbols | 32 + .../importCallExpressionErrorInES2015.types | 39 + .../importCallExpressionGrammarError.symbols | 25 + .../importCallExpressionGrammarError.types | 39 + ...portCallExpressionInScriptContext2.symbols | 13 + ...importCallExpressionInScriptContext2.types | 17 + .../importCallExpressionIncorrect1.symbols | 9 + .../importCallExpressionIncorrect1.types | 11 + .../importCallExpressionIncorrect2.symbols | 9 + .../importCallExpressionIncorrect2.types | 11 + ...allExpressionNoModuleKindSpecified.symbols | 67 + ...tCallExpressionNoModuleKindSpecified.types | 88 + ...ressionSpecifierNotStringTypeError.symbols | 37 + ...xpressionSpecifierNotStringTypeError.types | 57 + ...portCallExpressionWithTypeArgument.symbols | 15 + ...importCallExpressionWithTypeArgument.types | 20 + ...fereingExternalModuleWithNoResolve.symbols | 9 + ...RefereingExternalModuleWithNoResolve.types | 9 + .../reference/importDeclTypes.symbols | 13 + .../baselines/reference/importDeclTypes.types | 13 + .../importDeclWithClassModifiers.symbols | 24 + .../importDeclWithClassModifiers.types | 27 + .../importDeclWithDeclareModifier.symbols | 16 + .../importDeclWithDeclareModifier.types | 17 + ...ithDeclareModifierInAmbientContext.symbols | 19 + ...lWithDeclareModifierInAmbientContext.types | 19 + .../importDeclWithExportModifier.symbols | 16 + .../importDeclWithExportModifier.types | 17 + ...hExportModifierAndExportAssignment.symbols | 15 + ...ithExportModifierAndExportAssignment.types | 16 + ...ndExportAssignmentInAmbientContext.symbols | 17 + ...rAndExportAssignmentInAmbientContext.types | 17 + ...ortDeclarationInModuleDeclaration1.symbols | 7 + ...mportDeclarationInModuleDeclaration1.types | 7 + .../importHelpersInIsolatedModules.symbols | 91 + .../importHelpersInIsolatedModules.types | 91 + .../reference/importHelpersNoHelpers.symbols | 69 + .../reference/importHelpersNoHelpers.types | 73 + ...HelpersNoHelpersForAsyncGenerators.symbols | 13 + ...rtHelpersNoHelpersForAsyncGenerators.types | 22 + .../reference/importHelpersNoModule.symbols | 48 + .../reference/importHelpersNoModule.types | 48 + .../reference/importInsideModule.symbols | 11 + .../reference/importInsideModule.types | 13 + .../reference/importNonExternalModule.symbols | 18 + .../reference/importNonExternalModule.types | 23 + .../reference/importNonStringLiteral.symbols | 7 + .../reference/importNonStringLiteral.types | 9 + .../importStatementsInterfaces.symbols | 99 + .../importStatementsInterfaces.types | 106 + .../reference/importTsBeforeDTs.symbols | 19 + .../reference/importTsBeforeDTs.types | 26 + .../importWithTrailingSlash_noResolve.symbols | 4 + .../importWithTrailingSlash_noResolve.types | 4 + .../importedModuleAddToGlobal.symbols | 36 + .../reference/importedModuleAddToGlobal.types | 39 + .../importsImplicitlyReadonly.symbols | 61 + .../reference/importsImplicitlyReadonly.types | 79 + tests/baselines/reference/inOperator.symbols | 24 + tests/baselines/reference/inOperator.types | 31 + .../inOperatorWithInvalidOperands.symbols | 135 + .../inOperatorWithInvalidOperands.types | 164 + ...eAssignmentOfIdenticallyNamedTypes.symbols | 27 + ...bleAssignmentOfIdenticallyNamedTypes.types | 28 + .../reference/incompatibleExports1.symbols | 34 + .../reference/incompatibleExports1.types | 34 + .../reference/incompatibleExports2.symbols | 14 + .../reference/incompatibleExports2.types | 14 + .../incompatibleGenericTypes.symbols | 26 + .../reference/incompatibleGenericTypes.types | 26 + .../reference/incompatibleTypes.symbols | 180 + .../reference/incompatibleTypes.types | 208 + .../incompleteDottedExpressionAtEOF.symbols | 5 + .../incompleteDottedExpressionAtEOF.types | 8 + .../incompleteObjectLiteral1.symbols | 9 + .../reference/incompleteObjectLiteral1.types | 11 + .../incorrectClassOverloadChain.symbols | 14 + .../incorrectClassOverloadChain.types | 15 + .../reference/incrementAndDecrement.symbols | 141 + .../reference/incrementAndDecrement.types | 215 + .../incrementOnTypeParameter.symbols | 27 + .../reference/incrementOnTypeParameter.types | 32 + ...rWithAnyOtherTypeInvalidOperations.symbols | 198 + ...torWithAnyOtherTypeInvalidOperations.types | 274 + .../incrementOperatorWithEnumType.symbols | 30 + .../incrementOperatorWithEnumType.types | 36 + ...ratorWithEnumTypeInvalidOperations.symbols | 52 + ...peratorWithEnumTypeInvalidOperations.types | 74 + ...torWithNumberTypeInvalidOperations.symbols | 117 + ...ratorWithNumberTypeInvalidOperations.types | 171 + ...OperatorWithUnsupportedBooleanType.symbols | 164 + ...ntOperatorWithUnsupportedBooleanType.types | 222 + ...tOperatorWithUnsupportedStringType.symbols | 205 + ...entOperatorWithUnsupportedStringType.types | 288 + .../reference/indexIntoArraySubclass.symbols | 18 + .../reference/indexIntoArraySubclass.types | 22 + .../indexSignatureAndMappedType.symbols | 98 + .../indexSignatureAndMappedType.types | 104 + ...dexSignatureMustHaveTypeAnnotation.symbols | 24 + ...indexSignatureMustHaveTypeAnnotation.types | 27 + .../reference/indexSignatureTypeCheck.symbols | 39 + .../reference/indexSignatureTypeCheck.types | 44 + .../indexSignatureTypeCheck2.symbols | 36 + .../reference/indexSignatureTypeCheck2.types | 41 + .../indexSignatureTypeInference.symbols | 69 + .../indexSignatureTypeInference.types | 73 + ...SignatureWithAccessibilityModifier.symbols | 14 + ...exSignatureWithAccessibilityModifier.types | 14 + .../indexSignatureWithInitializer.symbols | 13 + .../indexSignatureWithInitializer.types | 19 + .../indexSignatureWithInitializer1.symbols | 7 + .../indexSignatureWithInitializer1.types | 8 + ...dexSignatureWithoutTypeAnnotation1.symbols | 7 + ...indexSignatureWithoutTypeAnnotation1.types | 7 + .../reference/indexTypeCheck.symbols | 144 + .../baselines/reference/indexTypeCheck.types | 167 + .../reference/indexWithUndefinedAndNull.types | 12 +- ...thUndefinedAndNullStrictNullChecks.symbols | 39 + ...WithUndefinedAndNullStrictNullChecks.types | 47 + .../reference/indexWithoutParamType.symbols | 4 + .../reference/indexWithoutParamType.types | 4 + .../reference/indexWithoutParamType2.symbols | 7 + .../reference/indexWithoutParamType2.types | 8 + tests/baselines/reference/indexer2A.symbols | 20 + tests/baselines/reference/indexer2A.types | 22 + .../reference/indexerAsOptional.symbols | 16 + .../reference/indexerAsOptional.types | 16 + .../reference/indexerConstraints.symbols | 95 + .../reference/indexerConstraints.types | 95 + .../reference/indexerConstraints2.symbols | 64 + .../reference/indexerConstraints2.types | 64 + .../indexerSignatureWithRestParam.symbols | 14 + .../indexerSignatureWithRestParam.types | 14 + .../reference/indirectSelfReference.symbols | 9 + .../reference/indirectSelfReference.types | 9 + .../indirectSelfReferenceGeneric.symbols | 13 + .../indirectSelfReferenceGeneric.types | 13 + ...ferFromGenericFunctionReturnTypes1.symbols | 303 + ...inferFromGenericFunctionReturnTypes1.types | 368 + .../reference/inferSetterParamType.symbols | 29 + .../reference/inferSetterParamType.types | 31 + .../reference/inferenceLimit.symbols | 4 +- ...lTypingWithObjectLiteralProperties.symbols | 27 + ...ialTypingWithObjectLiteralProperties.types | 49 + .../reference/inferingFromAny.symbols | 72 +- ...ferringClassMembersFromAssignments.symbols | 22 +- ...gClassStaticMembersFromAssignments.symbols | 18 +- ...initeExpansionThroughInstantiation.symbols | 68 + ...nfiniteExpansionThroughInstantiation.types | 70 + .../infinitelyExpandingOverloads.symbols | 88 + .../infinitelyExpandingOverloads.types | 90 + .../infinitelyExpandingTypes1.symbols | 66 + .../reference/infinitelyExpandingTypes1.types | 69 + .../infinitelyExpandingTypes2.symbols | 39 + .../reference/infinitelyExpandingTypes2.types | 45 + .../inheritFromGenericTypeParameter.symbols | 10 + .../inheritFromGenericTypeParameter.types | 11 + ...vatePropertiesFromDifferentOrigins.symbols | 23 + ...rivatePropertiesFromDifferentOrigins.types | 23 + ...PropertiesWithDifferentOptionality.symbols | 23 + ...mePropertiesWithDifferentOptionality.types | 23 + ...ePropertiesWithDifferentVisibility.symbols | 23 + ...amePropertiesWithDifferentVisibility.types | 23 + tests/baselines/reference/inheritance.symbols | 64 + tests/baselines/reference/inheritance.types | 69 + .../baselines/reference/inheritance1.symbols | 180 + tests/baselines/reference/inheritance1.types | 204 + ...eGrandParentPrivateMemberCollision.symbols | 20 + ...nceGrandParentPrivateMemberCollision.types | 20 + ...ateMemberCollisionWithPublicMember.symbols | 20 + ...ivateMemberCollisionWithPublicMember.types | 20 + ...icMemberCollisionWithPrivateMember.symbols | 20 + ...blicMemberCollisionWithPrivateMember.types | 20 + ...ceMemberAccessorOverridingAccessor.symbols | 31 + ...anceMemberAccessorOverridingAccessor.types | 33 + ...anceMemberAccessorOverridingMethod.symbols | 26 + ...itanceMemberAccessorOverridingMethod.types | 28 + ...ceMemberAccessorOverridingProperty.symbols | 23 + ...anceMemberAccessorOverridingProperty.types | 24 + ...itanceMemberFuncOverridingAccessor.symbols | 26 + ...eritanceMemberFuncOverridingAccessor.types | 28 + ...itanceMemberFuncOverridingProperty.symbols | 18 + ...eritanceMemberFuncOverridingProperty.types | 19 + ...ceMemberPropertyOverridingAccessor.symbols | 34 + ...anceMemberPropertyOverridingAccessor.types | 35 + ...anceMemberPropertyOverridingMethod.symbols | 18 + ...itanceMemberPropertyOverridingMethod.types | 19 + ...ceStaticAccessorOverridingAccessor.symbols | 31 + ...anceStaticAccessorOverridingAccessor.types | 33 + ...anceStaticAccessorOverridingMethod.symbols | 26 + ...itanceStaticAccessorOverridingMethod.types | 28 + ...ceStaticAccessorOverridingProperty.symbols | 23 + ...anceStaticAccessorOverridingProperty.types | 24 + ...itanceStaticFuncOverridingAccessor.symbols | 26 + ...eritanceStaticFuncOverridingAccessor.types | 28 + ...icFuncOverridingAccessorOfFuncType.symbols | 21 + ...aticFuncOverridingAccessorOfFuncType.types | 23 + ...itanceStaticFuncOverridingProperty.symbols | 18 + ...eritanceStaticFuncOverridingProperty.types | 19 + ...heritanceStaticMembersIncompatible.symbols | 15 + ...inheritanceStaticMembersIncompatible.types | 15 + ...ceStaticPropertyOverridingAccessor.symbols | 22 + ...anceStaticPropertyOverridingAccessor.types | 23 + ...anceStaticPropertyOverridingMethod.symbols | 18 + ...itanceStaticPropertyOverridingMethod.types | 19 + ...inheritedConstructorWithRestParams.symbols | 29 + .../inheritedConstructorWithRestParams.types | 40 + ...nheritedConstructorWithRestParams2.symbols | 99 + .../inheritedConstructorWithRestParams2.types | 139 + ...dIndexSignaturesFromDifferentBases.symbols | 64 + ...AndIndexSignaturesFromDifferentBases.types | 64 + .../inheritedModuleMembersForClodule.symbols | 40 + .../inheritedModuleMembersForClodule.types | 44 + ...ringIndexersFromDifferentBaseTypes.symbols | 60 + ...StringIndexersFromDifferentBaseTypes.types | 60 + ...ingIndexersFromDifferentBaseTypes2.symbols | 56 + ...tringIndexersFromDifferentBaseTypes2.types | 56 + ...alizerReferencingConstructorLocals.symbols | 50 + ...tializerReferencingConstructorLocals.types | 70 + ...erReferencingConstructorParameters.symbols | 62 + ...izerReferencingConstructorParameters.types | 70 + .../initializersInDeclarations.symbols | 31 + .../initializersInDeclarations.types | 40 + .../reference/inlineSourceMap.symbols | 7 + .../baselines/reference/inlineSourceMap.types | 12 + .../reference/inlineSourceMap2.symbols | 9 + .../reference/inlineSourceMap2.types | 14 + .../baselines/reference/inlineSources.symbols | 14 + tests/baselines/reference/inlineSources.types | 24 + .../reference/inlineSources2.symbols | 14 + .../baselines/reference/inlineSources2.types | 24 + .../baselines/reference/innerAliases.symbols | 48 + tests/baselines/reference/innerAliases.types | 57 + .../reference/innerModExport1.symbols | 35 + .../baselines/reference/innerModExport1.types | 44 + .../reference/innerModExport2.symbols | 35 + .../baselines/reference/innerModExport2.types | 46 + .../innerTypeCheckOfLambdaArgument.symbols | 22 + .../innerTypeCheckOfLambdaArgument.types | 25 + ...tanceMemberAssignsToClassPrototype.symbols | 46 + ...nstanceMemberAssignsToClassPrototype.types | 56 + ...cePropertiesInheritedIntoClassType.symbols | 144 + ...ancePropertiesInheritedIntoClassType.types | 160 + .../instancePropertyInClassType.symbols | 129 + .../instancePropertyInClassType.types | 145 + .../reference/instanceSubtypeCheck2.symbols | 20 + .../reference/instanceSubtypeCheck2.types | 20 + .../reference/instanceofOperator.symbols | 40 + .../reference/instanceofOperator.types | 52 + ...tanceofOperatorWithInvalidOperands.symbols | 142 + ...nstanceofOperatorWithInvalidOperands.types | 171 + ...ceofWithStructurallyIdenticalTypes.symbols | 6 +- ...anceofWithStructurallyIdenticalTypes.types | 12 +- ...lassWithWrongNumberOfTypeArguments.symbols | 36 + ...cClassWithWrongNumberOfTypeArguments.types | 38 + ...ateNonGenericTypeWithTypeArguments.symbols | 37 + ...tiateNonGenericTypeWithTypeArguments.types | 41 + .../instantiateTypeParameter.symbols | 8 + .../reference/instantiateTypeParameter.types | 9 + .../baselines/reference/intTypeCheck.symbols | 630 + tests/baselines/reference/intTypeCheck.types | 755 + .../interfaceAssignmentCompat.symbols | 162 + .../reference/interfaceAssignmentCompat.types | 204 + .../reference/interfaceDeclaration1.symbols | 106 + .../reference/interfaceDeclaration1.types | 108 + .../reference/interfaceDeclaration3.symbols | 137 + .../reference/interfaceDeclaration3.types | 137 + .../reference/interfaceDeclaration4.symbols | 86 + .../reference/interfaceDeclaration4.types | 87 + .../reference/interfaceDeclaration6.symbols | 24 + .../reference/interfaceDeclaration6.types | 24 + .../reference/interfaceExtendingClass.symbols | 56 + .../reference/interfaceExtendingClass.types | 59 + .../interfaceExtendingClass2.symbols | 33 + .../reference/interfaceExtendingClass2.types | 36 + ...nterfaceExtendingClassWithPrivates.symbols | 40 + .../interfaceExtendingClassWithPrivates.types | 40 + ...terfaceExtendingClassWithPrivates2.symbols | 68 + ...interfaceExtendingClassWithPrivates2.types | 68 + ...erfaceExtendingClassWithProtecteds.symbols | 40 + ...nterfaceExtendingClassWithProtecteds.types | 40 + ...rfaceExtendingClassWithProtecteds2.symbols | 68 + ...terfaceExtendingClassWithProtecteds2.types | 68 + .../interfaceExtendsClassWithPrivate1.symbols | 77 + .../interfaceExtendsClassWithPrivate1.types | 84 + .../interfaceExtendsClassWithPrivate2.symbols | 68 + .../interfaceExtendsClassWithPrivate2.types | 72 + ...aceExtendsObjectIntersectionErrors.symbols | 187 + ...rfaceExtendsObjectIntersectionErrors.types | 193 + .../interfaceImplementation1.symbols | 101 + .../reference/interfaceImplementation1.types | 109 + .../interfaceImplementation2.symbols | 31 + .../reference/interfaceImplementation2.types | 31 + .../interfaceImplementation3.symbols | 33 + .../reference/interfaceImplementation3.types | 33 + .../interfaceImplementation4.symbols | 31 + .../reference/interfaceImplementation4.types | 31 + .../interfaceImplementation5.symbols | 71 + .../reference/interfaceImplementation5.types | 73 + .../interfaceImplementation6.symbols | 45 + .../reference/interfaceImplementation6.types | 47 + .../interfaceImplementation7.symbols | 32 + .../reference/interfaceImplementation7.types | 33 + .../interfaceImplementation8.symbols | 79 + .../reference/interfaceImplementation8.types | 79 + .../reference/interfaceInheritance.symbols | 89 + .../reference/interfaceInheritance.types | 93 + .../interfaceMayNotBeExtendedWitACall.symbols | 9 + .../interfaceMayNotBeExtendedWitACall.types | 11 + .../interfaceMemberValidation.symbols | 28 + .../reference/interfaceMemberValidation.types | 28 + .../interfaceNameAsIdentifier.symbols | 20 + .../reference/interfaceNameAsIdentifier.types | 26 + .../reference/interfaceNaming1.symbols | 7 + .../reference/interfaceNaming1.types | 12 + .../interfacePropertiesWithSameName2.symbols | 78 + .../interfacePropertiesWithSameName2.types | 78 + .../interfacePropertiesWithSameName3.symbols | 27 + .../interfacePropertiesWithSameName3.types | 27 + .../interfaceThatHidesBaseProperty2.symbols | 21 + .../interfaceThatHidesBaseProperty2.types | 21 + ...ceThatIndirectlyInheritsFromItself.symbols | 58 + ...faceThatIndirectlyInheritsFromItself.types | 58 + .../interfaceThatInheritsFromItself.symbols | 25 + .../interfaceThatInheritsFromItself.types | 25 + ...nterfaceWithAccessibilityModifiers.symbols | 14 + .../interfaceWithAccessibilityModifiers.types | 14 + .../interfaceWithImplements1.symbols | 8 + .../reference/interfaceWithImplements1.types | 8 + .../interfaceWithMultipleBaseTypes.symbols | 153 + .../interfaceWithMultipleBaseTypes.types | 153 + .../interfaceWithMultipleBaseTypes2.symbols | 58 + .../interfaceWithMultipleBaseTypes2.types | 58 + .../interfaceWithMultipleDeclarations.symbols | 78 + .../interfaceWithMultipleDeclarations.types | 78 + .../interfaceWithPrivateMember.symbols | 25 + .../interfaceWithPrivateMember.types | 25 + ...ithPropertyThatIsPrivateInBaseType.symbols | 34 + ...eWithPropertyThatIsPrivateInBaseType.types | 34 + ...thPropertyThatIsPrivateInBaseType2.symbols | 33 + ...WithPropertyThatIsPrivateInBaseType2.types | 33 + ...StringIndexerHidingBaseTypeIndexer.symbols | 37 + ...thStringIndexerHidingBaseTypeIndexer.types | 37 + ...tringIndexerHidingBaseTypeIndexer2.symbols | 42 + ...hStringIndexerHidingBaseTypeIndexer2.types | 42 + ...tringIndexerHidingBaseTypeIndexer3.symbols | 33 + ...hStringIndexerHidingBaseTypeIndexer3.types | 33 + .../interfacedeclWithIndexerErrors.symbols | 94 + .../interfacedeclWithIndexerErrors.types | 95 + ...terfacesWithPredefinedTypesAsNames.symbols | 14 + ...interfacesWithPredefinedTypesAsNames.types | 18 + ...ocalModuleWithoutExportAccessError.symbols | 46 + ...eLocalModuleWithoutExportAccessError.types | 52 + ...ocalModuleWithoutExportAccessError.symbols | 38 + ...eLocalModuleWithoutExportAccessError.types | 42 + ...ocalModuleWithoutExportAccessError.symbols | 33 + ...eLocalModuleWithoutExportAccessError.types | 39 + ...ocalModuleWithoutExportAccessError.symbols | 34 + ...eLocalModuleWithoutExportAccessError.types | 40 + ...ocalModuleWithoutExportAccessError.symbols | 26 + ...eLocalModuleWithoutExportAccessError.types | 27 + ...ocalModuleWithoutExportAccessError.symbols | 40 + ...eLocalModuleWithoutExportAccessError.types | 43 + ...ocalModuleWithoutExportAccessError.symbols | 25 + ...eLocalModuleWithoutExportAccessError.types | 28 + ...gedWithClassNotReferencingInstance.symbols | 29 + ...ergedWithClassNotReferencingInstance.types | 31 + ...tiatedModuleNotReferencingInstance.symbols | 23 + ...antiatedModuleNotReferencingInstance.types | 25 + ...gedWithClassNotReferencingInstance.symbols | 26 + ...ergedWithClassNotReferencingInstance.types | 27 + .../intersectionAndUnionTypes.symbols | 147 + .../reference/intersectionAndUnionTypes.types | 167 + .../intersectionTypeAssignment.symbols | 59 + .../intersectionTypeAssignment.types | 69 + .../intersectionTypeInference.symbols | 98 + .../reference/intersectionTypeInference.types | 111 + .../intersectionTypeReadonly.symbols | 80 + .../reference/intersectionTypeReadonly.types | 90 + tests/baselines/reference/intrinsics.symbols | 34 + tests/baselines/reference/intrinsics.types | 41 + .../invalidAssignmentsToVoid.symbols | 66 + .../reference/invalidAssignmentsToVoid.types | 81 + ...tegerLiteralAndOctalIntegerLiteral.symbols | 14 + ...IntegerLiteralAndOctalIntegerLiteral.types | 22 + .../invalidBooleanAssignments.symbols | 79 + .../reference/invalidBooleanAssignments.types | 84 + .../reference/invalidConstraint1.symbols | 16 + .../reference/invalidConstraint1.types | 17 + .../invalidContinueInDownlevelAsync.symbols | 11 + .../invalidContinueInDownlevelAsync.types | 15 + .../invalidDoWhileBreakStatements.symbols | 44 + .../invalidDoWhileBreakStatements.types | 72 + .../invalidDoWhileContinueStatements.symbols | 44 + .../invalidDoWhileContinueStatements.types | 72 + .../reference/invalidEnumAssignments.symbols | 60 + .../reference/invalidEnumAssignments.types | 70 + .../invalidForBreakStatements.symbols | 43 + .../reference/invalidForBreakStatements.types | 62 + .../invalidForContinueStatements.symbols | 43 + .../invalidForContinueStatements.types | 62 + .../invalidForInBreakStatements.symbols | 54 + .../invalidForInBreakStatements.types | 79 + .../invalidForInContinueStatements.symbols | 54 + .../invalidForInContinueStatements.types | 79 + .../invalidImportAliasIdentifiers.symbols | 41 + .../invalidImportAliasIdentifiers.types | 45 + .../invalidInstantiatedModule.symbols | 34 + .../reference/invalidInstantiatedModule.types | 38 + .../invalidLetInForOfAndForIn_ES5.symbols | 14 + .../invalidLetInForOfAndForIn_ES5.types | 25 + .../invalidLetInForOfAndForIn_ES6.symbols | 14 + .../invalidLetInForOfAndForIn_ES6.types | 25 + ...lidModuleWithStatementsOfEveryKind.symbols | 178 + ...validModuleWithStatementsOfEveryKind.types | 178 + .../invalidModuleWithVarStatements.symbols | 49 + .../invalidModuleWithVarStatements.types | 52 + ...nvalidMultipleVariableDeclarations.symbols | 142 + .../invalidMultipleVariableDeclarations.types | 164 + .../reference/invalidNestedModules.symbols | 58 + .../reference/invalidNestedModules.types | 58 + .../reference/invalidNewTarget.es5.symbols | 62 + .../reference/invalidNewTarget.es5.types | 105 + .../reference/invalidNewTarget.es6.symbols | 62 + .../reference/invalidNewTarget.es6.types | 105 + .../invalidNumberAssignments.symbols | 68 + .../reference/invalidNumberAssignments.types | 75 + .../reference/invalidReferenceSyntax1.symbols | 6 + .../reference/invalidReferenceSyntax1.types | 6 + .../reference/invalidReturnStatements.symbols | 50 + .../reference/invalidReturnStatements.types | 53 + .../reference/invalidStaticField.symbols | 11 + .../reference/invalidStaticField.types | 14 + .../invalidStringAssignments.symbols | 77 + .../reference/invalidStringAssignments.types | 84 + .../invalidSwitchBreakStatement.types | 2 +- .../invalidSwitchContinueStatement.symbols | 9 + .../invalidSwitchContinueStatement.types | 12 + .../invalidSymbolInTypeParameter1.symbols | 9 + .../invalidSymbolInTypeParameter1.types | 11 + ...nvalidSyntaxNamespaceImportWithAMD.symbols | 9 + .../invalidSyntaxNamespaceImportWithAMD.types | 11 + ...dSyntaxNamespaceImportWithCommonjs.symbols | 9 + ...lidSyntaxNamespaceImportWithCommonjs.types | 11 + ...lidSyntaxNamespaceImportWithSystem.symbols | 9 + ...validSyntaxNamespaceImportWithSystem.types | 11 + .../reference/invalidThrowStatement.symbols | 6 + .../reference/invalidThrowStatement.types | 7 + .../invalidTripleSlashReference.symbols | 8 + .../invalidTripleSlashReference.types | 9 + .../reference/invalidTryStatements.symbols | 24 + .../reference/invalidTryStatements.types | 24 + .../reference/invalidTryStatements2.symbols | 29 + .../reference/invalidTryStatements2.types | 29 + .../reference/invalidTypeOfTarget.symbols | 25 + .../reference/invalidTypeOfTarget.types | 41 + .../invalidUndefinedAssignments.symbols | 65 + .../invalidUndefinedAssignments.types | 74 + .../invalidUnicodeEscapeSequance.symbols | 5 + .../invalidUnicodeEscapeSequance.types | 5 + .../invalidUnicodeEscapeSequance2.symbols | 5 + .../invalidUnicodeEscapeSequance2.types | 5 + .../invalidUnicodeEscapeSequance3.symbols | 3 + .../invalidUnicodeEscapeSequance3.types | 5 + .../invalidUnicodeEscapeSequance4.symbols | 7 + .../invalidUnicodeEscapeSequance4.types | 7 + .../invalidUseOfTypeAsNamespace.symbols | 8 + .../invalidUseOfTypeAsNamespace.types | 10 + .../reference/invalidVoidAssignments.symbols | 86 + .../reference/invalidVoidAssignments.types | 96 + .../reference/invalidVoidValues.symbols | 77 + .../reference/invalidVoidValues.types | 93 + .../invalidWhileBreakStatements.symbols | 44 + .../invalidWhileBreakStatements.types | 73 + .../invalidWhileContinueStatements.symbols | 44 + .../invalidWhileContinueStatements.types | 73 + ...ationExpressionInFunctionParameter.symbols | 10 + ...ocationExpressionInFunctionParameter.types | 12 + ...NonGenericMethodWithTypeArguments1.symbols | 10 + ...ngNonGenericMethodWithTypeArguments1.types | 13 + ...NonGenericMethodWithTypeArguments2.symbols | 15 + ...ngNonGenericMethodWithTypeArguments2.types | 16 + .../isDeclarationVisibleNodeKinds.symbols | 18 +- .../isolatedModulesAmbientConstEnum.symbols | 8 + .../isolatedModulesAmbientConstEnum.types | 9 + .../isolatedModulesDeclaration.symbols | 4 + .../isolatedModulesDeclaration.types | 4 + ...isolatedModulesImportExportElision.symbols | 32 + .../isolatedModulesImportExportElision.types | 35 + .../isolatedModulesNoEmitOnError.symbols | 4 + .../isolatedModulesNoEmitOnError.types | 4 + .../isolatedModulesNoExternalModule.symbols | 4 + .../isolatedModulesNoExternalModule.types | 4 + .../reference/isolatedModulesOut.symbols | 8 + .../reference/isolatedModulesOut.types | 8 + .../isolatedModulesPlainFile-AMD.symbols | 8 + .../isolatedModulesPlainFile-AMD.types | 10 + .../isolatedModulesPlainFile-CommonJS.symbols | 8 + .../isolatedModulesPlainFile-CommonJS.types | 10 + .../isolatedModulesPlainFile-ES6.symbols | 8 + .../isolatedModulesPlainFile-ES6.types | 10 + .../isolatedModulesPlainFile-System.symbols | 8 + .../isolatedModulesPlainFile-System.types | 10 + .../isolatedModulesPlainFile-UMD.symbols | 8 + .../isolatedModulesPlainFile-UMD.types | 10 + .../isolatedModulesReExportType.symbols | 47 + .../isolatedModulesReExportType.types | 47 + .../reference/iterableArrayPattern10.symbols | 46 + .../reference/iterableArrayPattern10.types | 52 + .../reference/iterableArrayPattern14.symbols | 46 + .../reference/iterableArrayPattern14.types | 52 + .../reference/iterableArrayPattern15.symbols | 47 + .../reference/iterableArrayPattern15.types | 54 + .../reference/iterableArrayPattern16.symbols | 74 + .../reference/iterableArrayPattern16.types | 85 + .../reference/iterableArrayPattern17.symbols | 47 + .../reference/iterableArrayPattern17.types | 53 + .../reference/iterableArrayPattern18.symbols | 47 + .../reference/iterableArrayPattern18.types | 53 + .../reference/iterableArrayPattern19.symbols | 47 + .../reference/iterableArrayPattern19.types | 54 + .../reference/iterableArrayPattern20.symbols | 49 + .../reference/iterableArrayPattern20.types | 60 + .../reference/iterableArrayPattern21.symbols | 5 + .../reference/iterableArrayPattern21.types | 8 + .../reference/iterableArrayPattern22.symbols | 4 + .../reference/iterableArrayPattern22.types | 7 + .../reference/iterableArrayPattern23.symbols | 9 + .../reference/iterableArrayPattern23.types | 14 + .../reference/iterableArrayPattern24.symbols | 9 + .../reference/iterableArrayPattern24.types | 15 + .../reference/iterableArrayPattern25.symbols | 12 + .../reference/iterableArrayPattern25.types | 21 + .../reference/iterableArrayPattern26.symbols | 12 + .../reference/iterableArrayPattern26.types | 21 + .../reference/iterableArrayPattern27.symbols | 12 + .../reference/iterableArrayPattern27.types | 22 + .../reference/iterableArrayPattern28.symbols | 12 + .../reference/iterableArrayPattern28.types | 22 + .../reference/iterableArrayPattern29.symbols | 12 + .../reference/iterableArrayPattern29.types | 22 + .../reference/iterableArrayPattern5.symbols | 47 + .../reference/iterableArrayPattern5.types | 54 + .../reference/iterableArrayPattern6.symbols | 47 + .../reference/iterableArrayPattern6.types | 55 + .../reference/iterableArrayPattern7.symbols | 47 + .../reference/iterableArrayPattern7.types | 54 + .../reference/iterableArrayPattern8.symbols | 47 + .../reference/iterableArrayPattern8.types | 55 + .../reference/iteratorSpreadInArray10.symbols | 18 + .../reference/iteratorSpreadInArray10.types | 21 + .../reference/iteratorSpreadInArray5.symbols | 32 + .../reference/iteratorSpreadInArray5.types | 41 + .../reference/iteratorSpreadInArray6.symbols | 37 + .../reference/iteratorSpreadInArray6.types | 48 + .../reference/iteratorSpreadInArray8.symbols | 23 + .../reference/iteratorSpreadInArray8.types | 30 + .../reference/iteratorSpreadInArray9.symbols | 29 + .../reference/iteratorSpreadInArray9.types | 35 + .../reference/iteratorSpreadInCall.symbols | 36 + .../reference/iteratorSpreadInCall.types | 43 + .../reference/iteratorSpreadInCall10.symbols | 39 + .../reference/iteratorSpreadInCall10.types | 48 + .../reference/iteratorSpreadInCall2.symbols | 36 + .../reference/iteratorSpreadInCall2.types | 43 + .../reference/iteratorSpreadInCall4.symbols | 37 + .../reference/iteratorSpreadInCall4.types | 44 + .../reference/iteratorSpreadInCall6.symbols | 63 + .../reference/iteratorSpreadInCall6.types | 76 + .../reference/iteratorSpreadInCall7.symbols | 66 + .../reference/iteratorSpreadInCall7.types | 81 + .../reference/iteratorSpreadInCall8.symbols | 68 + .../reference/iteratorSpreadInCall8.types | 81 + .../reference/iteratorSpreadInCall9.symbols | 68 + .../reference/iteratorSpreadInCall9.types | 83 + .../reference/jsFileClassPropertyType.symbols | 18 + .../reference/jsFileClassPropertyType.types | 24 + .../jsFileClassPropertyType2.symbols | 21 + .../reference/jsFileClassPropertyType2.types | 27 + .../jsFileClassPropertyType3.symbols | 26 + .../reference/jsFileClassPropertyType3.types | 36 + .../jsFileCompilationAbstractModifier.symbols | 7 + .../jsFileCompilationAbstractModifier.types | 7 + ...ilationAmbientVarDeclarationSyntax.symbols | 4 + ...mpilationAmbientVarDeclarationSyntax.types | 4 + ...CompilationBindDuplicateIdentifier.symbols | 7 + ...leCompilationBindDuplicateIdentifier.types | 8 + .../jsFileCompilationBindErrors.symbols | 21 + .../jsFileCompilationBindErrors.types | 26 + ...pilationBindMultipleDefaultExports.symbols | 7 + ...ompilationBindMultipleDefaultExports.types | 9 + ...eCompilationBindReachabilityErrors.symbols | 38 + ...ileCompilationBindReachabilityErrors.types | 45 + ...ileCompilationBindStrictModeErrors.symbols | 66 + ...sFileCompilationBindStrictModeErrors.types | 84 + ...ionDuplicateFunctionImplementation.symbols | 14 + ...ationDuplicateFunctionImplementation.types | 16 + ...ionImplementationFileOrderReversed.symbols | 15 + ...ctionImplementationFileOrderReversed.types | 17 + ...jsFileCompilationDuplicateVariable.symbols | 8 + .../jsFileCompilationDuplicateVariable.types | 10 + ...tionDuplicateVariableErrorReported.symbols | 8 + ...lationDuplicateVariableErrorReported.types | 10 + ...ileCompilationEmitBlockedCorrectly.symbols | 16 + ...sFileCompilationEmitBlockedCorrectly.types | 16 + .../jsFileCompilationEmitDeclarations.symbols | 10 + .../jsFileCompilationEmitDeclarations.types | 10 + ...mpilationEmitTrippleSlashReference.symbols | 15 + ...CompilationEmitTrippleSlashReference.types | 15 + .../jsFileCompilationEnumSyntax.symbols | 4 + .../jsFileCompilationEnumSyntax.types | 4 + ...ationsWithJsFileReferenceWithNoOut.symbols | 16 + ...arationsWithJsFileReferenceWithNoOut.types | 16 + ...arationsWithJsFileReferenceWithOut.symbols | 16 + ...clarationsWithJsFileReferenceWithOut.types | 16 + ...tionsWithJsFileReferenceWithOutDir.symbols | 16 + ...rationsWithJsFileReferenceWithOutDir.types | 16 + ...eCompilationExportAssignmentSyntax.symbols | 3 + ...ileCompilationExportAssignmentSyntax.types | 4 + ...ilationHeritageClauseSyntaxOfClass.symbols | 4 + ...mpilationHeritageClauseSyntaxOfClass.types | 5 + ...sFileCompilationImportEqualsSyntax.symbols | 4 + .../jsFileCompilationImportEqualsSyntax.types | 5 + .../jsFileCompilationInterfaceSyntax.symbols | 4 + .../jsFileCompilationInterfaceSyntax.types | 4 + ...FileCompilationLetDeclarationOrder.symbols | 14 + ...jsFileCompilationLetDeclarationOrder.types | 20 + ...ileCompilationLetDeclarationOrder2.symbols | 14 + ...sFileCompilationLetDeclarationOrder2.types | 20 + .../jsFileCompilationModuleSyntax.symbols | 4 + .../jsFileCompilationModuleSyntax.types | 4 + ...ationsWithJsFileReferenceWithNoOut.symbols | 16 + ...arationsWithJsFileReferenceWithNoOut.types | 16 + .../jsFileCompilationNonNullAssertion.symbols | 4 + .../jsFileCompilationNonNullAssertion.types | 5 + ...jsFileCompilationOptionalParameter.symbols | 5 + .../jsFileCompilationOptionalParameter.types | 5 + ...mpilationPublicMethodSyntaxOfClass.symbols | 8 + ...CompilationPublicMethodSyntaxOfClass.types | 8 + ...CompilationPublicParameterModifier.symbols | 5 + ...leCompilationPublicParameterModifier.types | 5 + ...pilationReturnTypeSyntaxOfFunction.symbols | 4 + ...ompilationReturnTypeSyntaxOfFunction.types | 4 + .../jsFileCompilationSyntaxError.symbols | 8 + .../jsFileCompilationSyntaxError.types | 8 + .../jsFileCompilationTypeAliasSyntax.symbols | 4 + .../jsFileCompilationTypeAliasSyntax.types | 5 + ...ompilationTypeArgumentSyntaxOfCall.symbols | 3 + ...eCompilationTypeArgumentSyntaxOfCall.types | 5 + .../jsFileCompilationTypeAssertions.symbols | 6 + .../jsFileCompilationTypeAssertions.types | 12 + .../jsFileCompilationTypeOfParameter.symbols | 5 + .../jsFileCompilationTypeOfParameter.types | 5 + ...pilationTypeParameterSyntaxOfClass.symbols | 5 + ...ompilationTypeParameterSyntaxOfClass.types | 5 + ...ationTypeParameterSyntaxOfFunction.symbols | 5 + ...ilationTypeParameterSyntaxOfFunction.types | 5 + .../jsFileCompilationTypeSyntaxOfVar.symbols | 4 + .../jsFileCompilationTypeSyntaxOfVar.types | 4 + ...WithDeclarationEmitPathSameAsInput.symbols | 9 + ...onWithDeclarationEmitPathSameAsInput.types | 9 + ...mpilationWithJsEmitPathSameAsInput.symbols | 10 + ...CompilationWithJsEmitPathSameAsInput.types | 10 + .../jsFileCompilationWithMapFileAsJs.symbols | 9 + .../jsFileCompilationWithMapFileAsJs.types | 9 + ...WithMapFileAsJsWithInlineSourceMap.symbols | 9 + ...onWithMapFileAsJsWithInlineSourceMap.types | 9 + ...mpilationWithMapFileAsJsWithOutDir.symbols | 5 + ...CompilationWithMapFileAsJsWithOutDir.types | 5 + ...clarationFileNameSameAsInputJsFile.symbols | 9 + ...DeclarationFileNameSameAsInputJsFile.types | 9 + ...onWithOutFileNameSameAsInputJsFile.symbols | 10 + ...tionWithOutFileNameSameAsInputJsFile.types | 10 + .../jsFileCompilationWithoutOut.symbols | 10 + .../jsFileCompilationWithoutOut.types | 10 + ...sFileFunctionParametersAsOptional2.symbols | 26 + .../jsFileFunctionParametersAsOptional2.types | 36 + ...ertyAssignedAfterMethodDeclaration.symbols | 15 + ...opertyAssignedAfterMethodDeclaration.types | 18 + .../jsdocDisallowedInTypescript.symbols | 77 + .../jsdocDisallowedInTypescript.types | 102 + .../reference/jsdocInTypeScript.symbols | 85 + .../reference/jsdocInTypeScript.types | 104 + .../jsdocParameterParsingInfiniteLoop.symbols | 8 + .../jsdocParameterParsingInfiniteLoop.types | 8 + .../jsdocParseErrorsInTypescript.symbols | 6 + .../jsdocParseErrorsInTypescript.types | 7 + ...TypeNongenericInstantiationAttempt.symbols | 100 + ...ocTypeNongenericInstantiationAttempt.types | 114 + .../reference/jsdocTypeTagCast.symbols | 158 + .../reference/jsdocTypeTagCast.types | 212 + .../reference/jsdocTypedefNoCrash2.symbols | 11 + .../reference/jsdocTypedefNoCrash2.types | 12 + .../reference/jsxAndTypeAssertion.symbols | 62 + .../reference/jsxAndTypeAssertion.types | 96 + ...jsxAttributeWithoutExpressionReact.symbols | 19 + .../jsxAttributeWithoutExpressionReact.types | 34 + .../reference/jsxEsprimaFbTestSuite.symbols | 127 + .../reference/jsxEsprimaFbTestSuite.types | 172 + .../jsxFactoryAndReactNamespace.symbols | 118 + .../jsxFactoryAndReactNamespace.types | 133 + ...ctoryIdentifierWithAbsentParameter.symbols | 23 + ...FactoryIdentifierWithAbsentParameter.types | 24 + ...actoryNotIdentifierOrQualifiedName.symbols | 118 + ...xFactoryNotIdentifierOrQualifiedName.types | 133 + ...ctoryNotIdentifierOrQualifiedName2.symbols | 118 + ...FactoryNotIdentifierOrQualifiedName2.types | 133 + ...actoryQualifiedNameResolutionError.symbols | 23 + ...xFactoryQualifiedNameResolutionError.types | 24 + .../jsxInvalidEsprimaTestSuite.symbols | 113 + .../jsxInvalidEsprimaTestSuite.types | 227 + .../reference/jsxParsingError1.symbols | 29 + .../reference/jsxParsingError1.types | 33 + .../reference/jsxParsingError2.symbols | 50 + .../reference/jsxParsingError2.types | 67 + .../baselines/reference/jsxViaImport.symbols | 45 + tests/baselines/reference/jsxViaImport.types | 46 + .../keyofAndIndexedAccessErrors.symbols | 270 + .../keyofAndIndexedAccessErrors.types | 301 + .../keyofIsLiteralContexualType.symbols | 44 + .../keyofIsLiteralContexualType.types | 61 + tests/baselines/reference/knockout.symbols | 98 + tests/baselines/reference/knockout.types | 109 + .../reference/lambdaArgCrash.symbols | 57 + .../baselines/reference/lambdaArgCrash.types | 63 + .../reference/lambdaParamTypes.symbols | 141 + .../reference/lambdaParamTypes.types | 197 + .../reference/lambdaPropSelf.symbols | 51 + .../baselines/reference/lambdaPropSelf.types | 59 + .../reference/largeControlFlowGraph.symbols | 30006 +++++++ .../reference/largeControlFlowGraph.types | 70007 ++++++++++++++++ .../lastPropertyInLiteralWins.symbols | 44 + .../reference/lastPropertyInLiteralWins.types | 54 + .../reference/letAndVarRedeclaration.symbols | 94 + .../reference/letAndVarRedeclaration.types | 94 + .../reference/letAsIdentifier.symbols | 14 + .../baselines/reference/letAsIdentifier.types | 18 + .../letAsIdentifierInStrictMode.symbols | 15 + .../letAsIdentifierInStrictMode.types | 21 + .../reference/letConstInCaseClauses.symbols | 57 + .../reference/letConstInCaseClauses.types | 83 + .../letDeclarations-invalidContexts.symbols | 53 + .../letDeclarations-invalidContexts.types | 81 + .../letDeclarations-scopes-duplicates.symbols | 129 + .../letDeclarations-scopes-duplicates.types | 162 + ...letDeclarations-scopes-duplicates2.symbols | 8 + .../letDeclarations-scopes-duplicates2.types | 10 + ...letDeclarations-scopes-duplicates3.symbols | 8 + .../letDeclarations-scopes-duplicates3.types | 10 + ...letDeclarations-scopes-duplicates4.symbols | 8 + .../letDeclarations-scopes-duplicates4.types | 10 + ...letDeclarations-scopes-duplicates5.symbols | 8 + .../letDeclarations-scopes-duplicates5.types | 10 + ...letDeclarations-scopes-duplicates6.symbols | 8 + .../letDeclarations-scopes-duplicates6.types | 10 + ...letDeclarations-scopes-duplicates7.symbols | 8 + .../letDeclarations-scopes-duplicates7.types | 10 + .../reference/letDeclarations-scopes.symbols | 312 + .../reference/letDeclarations-scopes.types | 400 + .../reference/letDeclarations-scopes2.symbols | 45 + .../reference/letDeclarations-scopes2.types | 53 + ...etDeclarations-useBeforeDefinition.symbols | 19 + .../letDeclarations-useBeforeDefinition.types | 20 + ...tDeclarations-useBeforeDefinition2.symbols | 8 + ...letDeclarations-useBeforeDefinition2.types | 9 + .../letDeclarations-validContexts.symbols | 225 + .../letDeclarations-validContexts.types | 293 + .../letInConstDeclarations_ES5.symbols | 11 + .../letInConstDeclarations_ES5.types | 15 + .../letInConstDeclarations_ES6.symbols | 11 + .../letInConstDeclarations_ES6.types | 15 + ...tInLetConstDeclOfForOfAndForIn_ES5.symbols | 29 + ...letInLetConstDeclOfForOfAndForIn_ES5.types | 61 + ...tInLetConstDeclOfForOfAndForIn_ES6.symbols | 29 + ...letInLetConstDeclOfForOfAndForIn_ES6.types | 61 + .../letInLetDeclarations_ES5.symbols | 11 + .../reference/letInLetDeclarations_ES5.types | 15 + .../letInLetDeclarations_ES6.symbols | 11 + .../reference/letInLetDeclarations_ES6.types | 15 + .../letShadowedByNameInNestedScope.symbols | 19 + .../letShadowedByNameInNestedScope.types | 29 + tests/baselines/reference/libMembers.symbols | 44 + tests/baselines/reference/libMembers.types | 68 + .../reference/library-reference-15.symbols | 12 + .../reference/library-reference-15.types | 18 + .../reference/library-reference-5.symbols | 20 + .../reference/library-reference-5.types | 20 + tests/baselines/reference/lift.symbols | 50 + tests/baselines/reference/lift.types | 63 + .../reference/limitDeepInstantiations.symbols | 22 + .../reference/limitDeepInstantiations.types | 22 + ...teralTypesWidenInParameterPosition.symbols | 24 + ...literalTypesWidenInParameterPosition.types | 32 + .../reference/literals-negative.symbols | 20 + .../reference/literals-negative.types | 31 + tests/baselines/reference/literals.symbols | 86 + tests/baselines/reference/literals.types | 113 + .../literalsInComputedProperties1.symbols | 143 + .../literalsInComputedProperties1.types | 185 + tests/baselines/reference/localTypes4.symbols | 88 + tests/baselines/reference/localTypes4.types | 98 + .../reference/logicalNotExpression1.symbols | 3 + .../reference/logicalNotExpression1.types | 5 + ...ogicalNotOperatorInvalidOperations.symbols | 20 + .../logicalNotOperatorInvalidOperations.types | 25 + ...logicalNotOperatorWithAnyOtherType.symbols | 178 + .../logicalNotOperatorWithAnyOtherType.types | 236 + ...calOrExpressionIsContextuallyTyped.symbols | 14 + ...gicalOrExpressionIsContextuallyTyped.types | 21 + .../looseThisTypeInFunctions.symbols | 183 + .../reference/looseThisTypeInFunctions.types | 214 + .../reference/mappedTypeErrors.symbols | 542 + .../reference/mappedTypeErrors.types | 643 + .../reference/mappedTypeErrors2.symbols | 71 + .../reference/mappedTypeErrors2.types | 76 + .../reference/mappedTypeIndexedAccess.symbols | 70 + .../reference/mappedTypeIndexedAccess.types | 76 + .../reference/mappedTypeModifiers.symbols | 32 +- .../reference/mappedTypeRelationships.symbols | 752 + .../reference/mappedTypeRelationships.types | 858 + .../mappedTypeWithCombinedTypeMappers.symbols | 55 + .../mappedTypeWithCombinedTypeMappers.types | 55 + .../matchReturnTypeInAllBranches.symbols | 97 + .../matchReturnTypeInAllBranches.types | 116 + .../reference/maxConstraints.symbols | 39 + .../baselines/reference/maxConstraints.types | 48 + ...maxNodeModuleJsDepthDefaultsToZero.symbols | 20 + .../maxNodeModuleJsDepthDefaultsToZero.types | 22 + .../maximum10SpellingSuggestions.symbols | 9 + .../maximum10SpellingSuggestions.types | 22 + ...ionOverloadMixingStaticAndInstance.symbols | 48 + ...ctionOverloadMixingStaticAndInstance.types | 48 + ...emberFunctionsWithPrivateOverloads.symbols | 175 + .../memberFunctionsWithPrivateOverloads.types | 183 + ...unctionsWithPublicPrivateOverloads.symbols | 222 + ...rFunctionsWithPublicPrivateOverloads.types | 226 + .../reference/memberOverride.symbols | 19 + .../baselines/reference/memberOverride.types | 22 + tests/baselines/reference/memberScope.symbols | 15 + tests/baselines/reference/memberScope.types | 18 + .../mergedClassWithNamespacePrototype.symbols | 16 + .../mergedClassWithNamespacePrototype.types | 16 + .../mergedDeclarationExports.symbols | 42 + .../reference/mergedDeclarationExports.types | 44 + .../reference/mergedDeclarations2.symbols | 21 + .../reference/mergedDeclarations2.types | 22 + .../reference/mergedDeclarations3.symbols | 93 + .../reference/mergedDeclarations3.types | 102 + .../reference/mergedDeclarations7.symbols | 45 + .../reference/mergedDeclarations7.types | 46 + ...rfacesWithConflictingPropertyNames.symbols | 85 + ...terfacesWithConflictingPropertyNames.types | 85 + .../mergedInterfacesWithIndexers2.symbols | 40 + .../mergedInterfacesWithIndexers2.types | 40 + ...gedInterfacesWithInheritedPrivates.symbols | 61 + ...ergedInterfacesWithInheritedPrivates.types | 61 + ...edInterfacesWithInheritedPrivates2.symbols | 77 + ...rgedInterfacesWithInheritedPrivates2.types | 77 + ...edInterfacesWithInheritedPrivates3.symbols | 76 + ...rgedInterfacesWithInheritedPrivates3.types | 76 + ...mergedInterfacesWithMultipleBases4.symbols | 83 + .../mergedInterfacesWithMultipleBases4.types | 83 + .../reference/methodInAmbientClass1.symbols | 8 + .../reference/methodInAmbientClass1.types | 8 + .../methodSignaturesWithOverloads.symbols | 56 + .../methodSignaturesWithOverloads.types | 56 + ...mismatchedClassConstructorVariable.symbols | 11 + .../mismatchedClassConstructorVariable.types | 11 + ...plicitTypeParameterAndArgumentType.symbols | 73 + ...ExplicitTypeParameterAndArgumentType.types | 122 + .../missingAndExcessProperties.symbols | 105 + .../missingAndExcessProperties.types | 173 + .../reference/missingArgument1.symbols | 3 + .../reference/missingArgument1.types | 8 + .../reference/missingDecoratorType.symbols | 44 + .../reference/missingDecoratorType.types | 44 + .../missingFunctionImplementation.symbols | 159 + .../missingFunctionImplementation.types | 159 + .../missingFunctionImplementation2.symbols | 15 + .../missingFunctionImplementation2.types | 15 + ...missingPropertiesOfClassExpression.symbols | 12 + .../missingPropertiesOfClassExpression.types | 16 + .../missingRequiredDeclare.d.symbols | 4 + .../reference/missingRequiredDeclare.d.types | 5 + .../reference/missingReturnStatement.symbols | 13 + .../reference/missingReturnStatement.types | 13 + .../reference/missingReturnStatement1.symbols | 11 + .../reference/missingReturnStatement1.types | 11 + .../reference/missingTypeArguments1.symbols | 135 + .../reference/missingTypeArguments1.types | 135 + .../reference/missingTypeArguments2.symbols | 21 + .../reference/missingTypeArguments2.types | 24 + .../misspelledNewMetaProperty.symbols | 4 + .../reference/misspelledNewMetaProperty.types | 6 + ...mixedStaticAndInstanceClassMembers.symbols | 40 + .../mixedStaticAndInstanceClassMembers.types | 40 + .../reference/mixinAccessModifiers.symbols | 330 + .../reference/mixinAccessModifiers.types | 336 + .../mixinPrivateAndProtected.symbols | 260 + .../reference/mixinPrivateAndProtected.types | 296 + .../mixingStaticAndInstanceOverloads.symbols | 94 + .../mixingStaticAndInstanceOverloads.types | 94 + .../reference/modifierOnParameter1.symbols | 7 + .../reference/modifierOnParameter1.types | 7 + .../modifiersInObjectLiterals.symbols | 32 + .../reference/modifiersInObjectLiterals.types | 40 + ...odifiersOnInterfaceIndexSignature1.symbols | 7 + .../modifiersOnInterfaceIndexSignature1.types | 7 + ...omUsingES6ArrayWithOnlyES6ArrayLib.symbols | 15 + ...FromUsingES6ArrayWithOnlyES6ArrayLib.types | 23 + ...FromUsingES6FeaturesWithOnlyES5Lib.symbols | 97 + ...orFromUsingES6FeaturesWithOnlyES5Lib.types | 154 + ...SymbolWithOutES6WellknownSymbolLib.symbols | 23 + ...wnSymbolWithOutES6WellknownSymbolLib.types | 37 + .../moduleAndInterfaceSharingName2.symbols | 24 + .../moduleAndInterfaceSharingName2.types | 25 + .../moduleAndInterfaceWithSameName.symbols | 58 + .../moduleAndInterfaceWithSameName.types | 65 + .../reference/moduleAsBaseType.symbols | 13 + .../reference/moduleAsBaseType.types | 16 + .../reference/moduleAssignmentCompat1.symbols | 33 + .../reference/moduleAssignmentCompat1.types | 37 + .../reference/moduleAssignmentCompat2.symbols | 31 + .../reference/moduleAssignmentCompat2.types | 35 + .../reference/moduleAssignmentCompat3.symbols | 29 + .../reference/moduleAssignmentCompat3.types | 35 + .../reference/moduleAssignmentCompat4.symbols | 36 + .../reference/moduleAssignmentCompat4.types | 40 + ...leAugmentationDisallowedExtensions.symbols | 101 + ...duleAugmentationDisallowedExtensions.types | 105 + .../moduleAugmentationGlobal6.symbols | 9 + .../reference/moduleAugmentationGlobal6.types | 9 + .../moduleAugmentationGlobal6_1.symbols | 9 + .../moduleAugmentationGlobal6_1.types | 9 + .../moduleAugmentationGlobal7.symbols | 13 + .../reference/moduleAugmentationGlobal7.types | 13 + .../moduleAugmentationGlobal7_1.symbols | 13 + .../moduleAugmentationGlobal7_1.types | 13 + .../moduleAugmentationGlobal8.symbols | 15 + .../reference/moduleAugmentationGlobal8.types | 15 + .../moduleAugmentationGlobal8_1.symbols | 15 + .../moduleAugmentationGlobal8_1.types | 15 + ...duleAugmentationImportsAndExports2.symbols | 83 + ...moduleAugmentationImportsAndExports2.types | 92 + ...duleAugmentationImportsAndExports3.symbols | 83 + ...moduleAugmentationImportsAndExports3.types | 88 + ...duleAugmentationImportsAndExports5.symbols | 100 + ...moduleAugmentationImportsAndExports5.types | 105 + .../moduleAugmentationInDependency2.symbols | 8 + .../moduleAugmentationInDependency2.types | 8 + .../moduleClassArrayCodeGenTest.symbols | 22 + .../moduleClassArrayCodeGenTest.types | 25 + .../reference/moduleCrashBug1.symbols | 31 + .../baselines/reference/moduleCrashBug1.types | 32 + .../moduleDuplicateIdentifiers.symbols | 75 + .../moduleDuplicateIdentifiers.types | 85 + .../moduleElementsInWrongContext.symbols | 65 + .../moduleElementsInWrongContext.types | 65 + .../moduleElementsInWrongContext2.symbols | 67 + .../moduleElementsInWrongContext2.types | 67 + .../moduleElementsInWrongContext3.symbols | 67 + .../moduleElementsInWrongContext3.types | 67 + .../reference/moduleExports1.symbols | 32 + .../baselines/reference/moduleExports1.types | 47 + .../baselines/reference/moduleImport.symbols | 42 + tests/baselines/reference/moduleImport.types | 56 + .../reference/moduleInTypePosition1.symbols | 17 + .../reference/moduleInTypePosition1.types | 19 + .../moduleKeywordRepeatError.symbols | 5 + .../reference/moduleKeywordRepeatError.types | 8 + .../reference/moduleNewExportBug.symbols | 26 + .../reference/moduleNewExportBug.types | 27 + .../reference/moduleNoneErrors.symbols | 8 + .../reference/moduleNoneErrors.types | 8 + .../reference/moduleProperty1.symbols | 28 + .../baselines/reference/moduleProperty1.types | 33 + .../reference/moduleProperty2.symbols | 37 + .../baselines/reference/moduleProperty2.types | 40 + .../reference/moduleResolutionNoTs.symbols | 33 + .../reference/moduleResolutionNoTs.types | 33 + .../moduleResolutionWithExtensions.symbols | 1 - .../moduleResolutionWithExtensions.types | 1 - ...olutionWithExtensions_notSupported.symbols | 10 + ...esolutionWithExtensions_notSupported.types | 10 + ...lutionWithExtensions_notSupported2.symbols | 4 + ...solutionWithExtensions_notSupported2.types | 4 + ...utionWithSymlinks_preserveSymlinks.symbols | 25 + ...olutionWithSymlinks_preserveSymlinks.types | 28 + ...relativeImportJsFile_noImplicitAny.symbols | 4 + ...n_relativeImportJsFile_noImplicitAny.types | 4 + ...NameWithImportDeclarationInsideIt3.symbols | 38 + ...esNameWithImportDeclarationInsideIt3.types | 40 + ...NameWithImportDeclarationInsideIt5.symbols | 38 + ...esNameWithImportDeclarationInsideIt5.types | 40 + .../reference/moduleVisibilityTest2.symbols | 152 + .../reference/moduleVisibilityTest2.types | 186 + .../reference/moduleVisibilityTest3.symbols | 46 + .../reference/moduleVisibilityTest3.types | 49 + .../moduleWithNoValuesAsType.symbols | 30 + .../reference/moduleWithNoValuesAsType.types | 33 + .../reference/moduleWithValuesAsType.symbols | 11 + .../reference/moduleWithValuesAsType.types | 13 + ...ule_augmentExistingAmbientVariable.symbols | 10 + ...odule_augmentExistingAmbientVariable.types | 11 + .../module_augmentExistingVariable.symbols | 10 + .../module_augmentExistingVariable.types | 11 + ...odule_augmentUninstantiatedModule2.symbols | 26 +- .../module_augmentUninstantiatedModule2.types | 26 +- .../multiExtendsSplitInterfaces1.symbols | 3 + .../multiExtendsSplitInterfaces1.types | 8 + .../reference/multiLineErrors.symbols | 48 + .../baselines/reference/multiLineErrors.types | 52 + ...pertyAccessAndArrowFunctionIndent1.symbols | 12 + ...ropertyAccessAndArrowFunctionIndent1.types | 38 + ...nterfaesWithIncompatibleProperties.symbols | 15 + ...eInterfaesWithIncompatibleProperties.types | 15 + .../multipleClassPropertyModifiers.symbols | 16 + .../multipleClassPropertyModifiers.types | 16 + ...ltipleClassPropertyModifiersErrors.symbols | 25 + ...multipleClassPropertyModifiersErrors.types | 25 + .../multipleDefaultExports01.symbols | 24 + .../reference/multipleDefaultExports01.types | 26 + .../multipleDefaultExports02.symbols | 18 + .../reference/multipleDefaultExports02.types | 19 + .../multipleDefaultExports03.symbols | 8 + .../reference/multipleDefaultExports03.types | 8 + .../multipleDefaultExports04.symbols | 8 + .../reference/multipleDefaultExports04.types | 8 + .../multipleExportAssignments.symbols | 44 + .../reference/multipleExportAssignments.types | 44 + ...ortAssignmentsInAmbientDeclaration.symbols | 14 + ...xportAssignmentsInAmbientDeclaration.types | 14 + .../reference/multipleExportDefault1.symbols | 12 + .../reference/multipleExportDefault1.types | 15 + .../reference/multipleExportDefault2.symbols | 11 + .../reference/multipleExportDefault2.types | 14 + .../reference/multipleExportDefault3.symbols | 11 + .../reference/multipleExportDefault3.types | 14 + .../reference/multipleExportDefault4.symbols | 9 + .../reference/multipleExportDefault4.types | 12 + .../reference/multipleExportDefault5.symbols | 7 + .../reference/multipleExportDefault5.types | 7 + .../reference/multipleExportDefault6.symbols | 10 + .../reference/multipleExportDefault6.types | 16 + .../reference/multipleExports.symbols | 24 + .../baselines/reference/multipleExports.types | 26 + .../reference/multipleInheritance.symbols | 74 + .../reference/multipleInheritance.types | 79 + .../reference/multipleNumericIndexers.symbols | 66 + .../reference/multipleNumericIndexers.types | 69 + .../reference/multipleStringIndexers.symbols | 66 + .../reference/multipleStringIndexers.types | 68 + tests/baselines/reference/multivar.symbols | 110 + tests/baselines/reference/multivar.types | 124 + .../reference/nameCollisions.symbols | 91 + .../baselines/reference/nameCollisions.types | 92 + .../namedFunctionExpressionCallErrors.symbols | 23 + .../namedFunctionExpressionCallErrors.types | 35 + .../reference/namespacesDeclaration2.symbols | 33 + .../reference/namespacesDeclaration2.types | 36 + ...rrowExceptionVariableInCatchClause.symbols | 50 + ...narrowExceptionVariableInCatchClause.types | 58 + .../narrowFromAnyWithInstanceof.symbols | 58 + .../narrowFromAnyWithInstanceof.types | 81 + .../narrowFromAnyWithTypePredicate.symbols | 99 + .../narrowFromAnyWithTypePredicate.types | 127 + ...narrowingGenericTypeFromInstanceof01.types | 28 +- .../reference/nativeToBoxedTypes.symbols | 44 + .../reference/nativeToBoxedTypes.types | 55 + .../negateOperatorInvalidOperations.symbols | 25 + .../negateOperatorInvalidOperations.types | 42 + .../negateOperatorWithAnyOtherType.symbols | 4 +- .../negateOperatorWithAnyOtherType.types | 4 +- .../nestedBlockScopedBindings13.symbols | 16 + .../nestedBlockScopedBindings13.types | 23 + .../nestedBlockScopedBindings14.symbols | 22 + .../nestedBlockScopedBindings14.types | 29 + .../nestedBlockScopedBindings15.symbols | 46 + .../nestedBlockScopedBindings15.types | 66 + .../nestedBlockScopedBindings16.symbols | 58 + .../nestedBlockScopedBindings16.types | 78 + .../nestedBlockScopedBindings5.symbols | 163 + .../nestedBlockScopedBindings5.types | 227 + .../nestedBlockScopedBindings7.symbols | 14 + .../nestedBlockScopedBindings7.types | 19 + .../nestedBlockScopedBindings8.symbols | 20 + .../nestedBlockScopedBindings8.types | 25 + .../reference/nestedClassDeclaration.symbols | 30 + .../reference/nestedClassDeclaration.types | 32 + .../reference/nestedFreshLiteral.symbols | 31 + .../reference/nestedFreshLiteral.types | 35 + .../reference/neverTypeErrors1.symbols | 42 + .../reference/neverTypeErrors1.types | 54 + .../reference/neverTypeErrors2.symbols | 42 + .../reference/neverTypeErrors2.types | 54 + .../reference/newAbstractInstance.symbols | 11 + .../reference/newAbstractInstance.types | 12 + .../reference/newExpressionWithCast.symbols | 26 + .../reference/newExpressionWithCast.types | 36 + .../reference/newFunctionImplicitAny.symbols | 10 + .../reference/newFunctionImplicitAny.types | 11 + .../reference/newMissingIdentifier.symbols | 4 + .../reference/newMissingIdentifier.types | 7 + .../newNamesInGlobalAugmentations1.symbols | 51 + .../newNamesInGlobalAugmentations1.types | 54 + .../reference/newNonReferenceType.symbols | 7 + .../reference/newNonReferenceType.types | 11 + .../reference/newOnInstanceSymbol.symbols | 11 + .../reference/newOnInstanceSymbol.types | 13 + tests/baselines/reference/newOperator.symbols | 86 + tests/baselines/reference/newOperator.types | 114 + .../reference/newOperatorErrorCases.symbols | 73 + .../reference/newOperatorErrorCases.types | 81 + .../baselines/reference/newWithSpread.symbols | 273 + tests/baselines/reference/newWithSpread.types | 494 + ...isExpressionAndLocalVarInAccessors.symbols | 94 + ...ThisExpressionAndLocalVarInAccessors.types | 116 + .../noCrashOnImportShadowing.symbols | 51 + .../reference/noCrashOnImportShadowing.types | 60 + .../baselines/reference/noDefaultLib.symbols | 26 + tests/baselines/reference/noDefaultLib.types | 26 + .../baselines/reference/noEmitOnError.symbols | 4 + tests/baselines/reference/noEmitOnError.types | 5 + .../reference/noErrorTruncation.symbols | 46 + .../reference/noErrorTruncation.types | 47 + ...duleAugmentationInDeclarationFile2.symbols | 11 + ...ModuleAugmentationInDeclarationFile2.types | 12 + ...duleAugmentationInDeclarationFile3.symbols | 11 + ...ModuleAugmentationInDeclarationFile3.types | 12 + .../reference/noErrorsInCallback.symbols | 21 + .../reference/noErrorsInCallback.types | 28 + ...yDestructuringParameterDeclaration.symbols | 42 + ...AnyDestructuringParameterDeclaration.types | 48 + ...icitAnyDestructuringVarDeclaration.symbols | 41 + ...plicitAnyDestructuringVarDeclaration.types | 48 + .../reference/noImplicitAnyForIn.symbols | 66 + .../reference/noImplicitAnyForIn.types | 95 + .../noImplicitAnyForMethodParameters.symbols | 31 + .../noImplicitAnyForMethodParameters.types | 31 + ...licitAnyForwardReferencedInterface.symbols | 11 + ...mplicitAnyForwardReferencedInterface.types | 11 + .../reference/noImplicitAnyFunctions.symbols | 45 + .../reference/noImplicitAnyFunctions.types | 46 + .../noImplicitAnyInBareInterface.symbols | 12 + .../noImplicitAnyInBareInterface.types | 12 + .../noImplicitAnyInCastExpression.symbols | 30 + .../noImplicitAnyInCastExpression.types | 42 + .../reference/noImplicitAnyIndexing.symbols | 101 + .../reference/noImplicitAnyIndexing.types | 130 + .../noImplicitAnyMissingGetAccessor.symbols | 27 + .../noImplicitAnyMissingGetAccessor.types | 28 + .../noImplicitAnyMissingSetAccessor.symbols | 18 + .../noImplicitAnyMissingSetAccessor.types | 19 + .../reference/noImplicitAnyModule.symbols | 35 + .../reference/noImplicitAnyModule.types | 35 + ...mplicitAnyParametersInAmbientClass.symbols | 184 + ...oImplicitAnyParametersInAmbientClass.types | 184 + ...citAnyParametersInAmbientFunctions.symbols | 90 + ...licitAnyParametersInAmbientFunctions.types | 90 + ...plicitAnyParametersInAmbientModule.symbols | 93 + ...ImplicitAnyParametersInAmbientModule.types | 93 + ...plicitAnyParametersInBareFunctions.symbols | 90 + ...ImplicitAnyParametersInBareFunctions.types | 102 + .../noImplicitAnyParametersInClass.symbols | 184 + .../noImplicitAnyParametersInClass.types | 208 + ...noImplicitAnyParametersInInterface.symbols | 103 + .../noImplicitAnyParametersInInterface.types | 103 + .../noImplicitAnyParametersInModule.symbols | 93 + .../noImplicitAnyParametersInModule.types | 105 + ...citAnyReferencingDeclaredInterface.symbols | 12 + ...licitAnyReferencingDeclaredInterface.types | 12 + ...noImplicitAnyStringIndexerOnObject.symbols | 8 + .../noImplicitAnyStringIndexerOnObject.types | 14 + .../noImplicitAnyWithOverloads.symbols | 33 + .../noImplicitAnyWithOverloads.types | 35 + .../noImplicitReturnsInAsync2.symbols | 66 + .../reference/noImplicitReturnsInAsync2.types | 82 + ...mplicitReturnsWithProtectedBlocks2.symbols | 26 + ...oImplicitReturnsWithProtectedBlocks2.types | 31 + ...mplicitReturnsWithProtectedBlocks3.symbols | 22 + ...oImplicitReturnsWithProtectedBlocks3.types | 25 + ...icitReturnsWithoutReturnExpression.symbols | 39 + ...plicitReturnsWithoutReturnExpression.types | 40 + .../reference/noImplicitThisFunctions.symbols | 35 + .../reference/noImplicitThisFunctions.types | 48 + .../reference/noSymbolForMergeCrash.symbols | 11 + .../reference/noSymbolForMergeCrash.types | 11 + .../noTypeArgumentOnReturnType1.symbols | 12 + .../noTypeArgumentOnReturnType1.types | 13 + .../noUnusedLocals_selfReference.symbols | 43 + .../noUnusedLocals_selfReference.types | 44 + .../noUnusedLocals_writeOnly.symbols | 23 + .../reference/noUnusedLocals_writeOnly.types | 32 + .../noUnusedLocals_writeOnlyProperty.symbols | 17 + .../noUnusedLocals_writeOnlyProperty.types | 19 + .../reference/nonArrayRestArgs.symbols | 12 + .../reference/nonArrayRestArgs.types | 14 + ...nonExportedElementsOfMergedModules.symbols | 38 + .../nonExportedElementsOfMergedModules.types | 40 + ...ericTypeReferenceWithTypeArguments.symbols | 68 + ...enericTypeReferenceWithTypeArguments.types | 68 + .../nonIdenticalTypeConstraints.symbols | 104 + .../nonIdenticalTypeConstraints.types | 104 + .../reference/nonIterableRestElement3.symbols | 8 + .../reference/nonIterableRestElement3.types | 16 + .../nonMergedDeclarationsAndOverloads.symbols | 23 + .../nonMergedDeclarationsAndOverloads.types | 23 + .../reference/nonMergedOverloads.symbols | 10 + .../reference/nonMergedOverloads.types | 11 + .../nonPrimitiveAccessProperty.symbols | 20 + .../nonPrimitiveAccessProperty.types | 24 + .../reference/nonPrimitiveAsProperty.symbols | 19 + .../reference/nonPrimitiveAsProperty.types | 24 + .../reference/nonPrimitiveAssignError.symbols | 84 + .../reference/nonPrimitiveAssignError.types | 106 + .../reference/nonPrimitiveInFunction.symbols | 43 + .../reference/nonPrimitiveInFunction.types | 51 + .../reference/nonPrimitiveInGeneric.symbols | 113 + .../reference/nonPrimitiveInGeneric.types | 132 + ...tiveIndexingWithForInNoImplicitAny.symbols | 14 + ...mitiveIndexingWithForInNoImplicitAny.types | 15 + .../reference/nonPrimitiveNarrow.symbols | 47 + .../reference/nonPrimitiveNarrow.types | 64 + .../reference/nonPrimitiveStrictNull.symbols | 147 + .../reference/nonPrimitiveStrictNull.types | 196 + .../nonPrimitiveUnionIntersection.symbols | 27 + .../nonPrimitiveUnionIntersection.types | 36 + tests/baselines/reference/null.symbols | 31 +- tests/baselines/reference/null.types | 5 +- .../reference/nullAssignedToUndefined.symbols | 9 + .../reference/nullAssignedToUndefined.types | 12 + tests/baselines/reference/nullKeyword.symbols | 3 + tests/baselines/reference/nullKeyword.types | 6 + .../reference/numberToString.symbols | 23 + .../baselines/reference/numberToString.types | 31 + .../reference/numericClassMembers1.symbols | 22 + .../reference/numericClassMembers1.types | 31 + .../reference/numericIndexExpressions.symbols | 37 + .../reference/numericIndexExpressions.types | 49 + ...exerConstrainsPropertyDeclarations.symbols | 172 + ...ndexerConstrainsPropertyDeclarations.types | 197 + ...xerConstrainsPropertyDeclarations2.symbols | 96 + ...dexerConstrainsPropertyDeclarations2.types | 105 + .../numericIndexerConstraint.symbols | 9 + .../reference/numericIndexerConstraint.types | 9 + .../numericIndexerConstraint1.symbols | 14 + .../reference/numericIndexerConstraint1.types | 16 + .../numericIndexerConstraint2.symbols | 18 + .../reference/numericIndexerConstraint2.types | 19 + .../numericIndexerConstraint5.symbols | 11 + .../reference/numericIndexerConstraint5.types | 14 + .../reference/numericIndexerTyping1.symbols | 30 + .../reference/numericIndexerTyping1.types | 34 + .../reference/numericIndexerTyping2.symbols | 30 + .../reference/numericIndexerTyping2.types | 34 + .../reference/numericLiteralTypes1.symbols | 38 +- .../reference/numericLiteralTypes2.symbols | 38 +- .../reference/numericLiteralTypes3.symbols | 336 + .../reference/numericLiteralTypes3.types | 443 + ...iteralsWithTrailingDecimalPoints01.symbols | 63 + ...cLiteralsWithTrailingDecimalPoints01.types | 96 + .../numericNamedPropertyDuplicates.symbols | 30 + .../numericNamedPropertyDuplicates.types | 34 + ...ericStringNamedPropertyEquivalence.symbols | 32 + ...umericStringNamedPropertyEquivalence.types | 36 + ...BindingPatternKeywordIdentifiers01.symbols | 6 + ...ctBindingPatternKeywordIdentifiers01.types | 8 + ...BindingPatternKeywordIdentifiers02.symbols | 8 + ...ctBindingPatternKeywordIdentifiers02.types | 10 + ...BindingPatternKeywordIdentifiers03.symbols | 5 + ...ctBindingPatternKeywordIdentifiers03.types | 7 + ...BindingPatternKeywordIdentifiers04.symbols | 7 + ...ctBindingPatternKeywordIdentifiers04.types | 9 + .../reference/objectCreate-errors.symbols | 52 + .../reference/objectCreate-errors.types | 70 + ...ationExpressionInFunctionParameter.symbols | 14 + ...reationExpressionInFunctionParameter.types | 16 + ...tCreationOfElementAccessExpression.symbols | 143 + ...ectCreationOfElementAccessExpression.types | 186 + .../baselines/reference/objectFreeze.symbols | 57 + tests/baselines/reference/objectFreeze.types | 85 + .../reference/objectLitArrayDeclNoNew.symbols | 56 + .../reference/objectLitArrayDeclNoNew.types | 63 + .../objectLitIndexerContextualType.symbols | 64 + .../objectLitIndexerContextualType.types | 80 + .../objectLitPropertyScoping.symbols | 37 + .../reference/objectLitPropertyScoping.types | 44 + .../objectLitStructuralTypeMismatch.symbols | 7 + .../objectLitStructuralTypeMismatch.types | 9 + .../objectLitTargetTypeCallSite.symbols | 18 + .../objectLitTargetTypeCallSite.types | 22 + .../reference/objectLiteralErrors.symbols | 161 + .../reference/objectLiteralErrors.types | 276 + .../reference/objectLiteralErrorsES3.symbols | 17 + .../reference/objectLiteralErrorsES3.types | 22 + .../objectLiteralExcessProperties.symbols | 89 + .../objectLiteralExcessProperties.types | 121 + .../objectLiteralFreshnessWithSpread.symbols | 14 + .../objectLiteralFreshnessWithSpread.types | 20 + ...LiteralFunctionArgContextualTyping.symbols | 49 + ...ctLiteralFunctionArgContextualTyping.types | 71 + ...iteralFunctionArgContextualTyping2.symbols | 49 + ...tLiteralFunctionArgContextualTyping2.types | 71 + .../objectLiteralGettersAndSetters.symbols | 256 + .../objectLiteralGettersAndSetters.types | 295 + .../objectLiteralIndexerErrors.symbols | 43 + .../objectLiteralIndexerErrors.types | 46 + .../objectLiteralMemberWithModifiers1.symbols | 5 + .../objectLiteralMemberWithModifiers1.types | 6 + .../objectLiteralMemberWithModifiers2.symbols | 5 + .../objectLiteralMemberWithModifiers2.types | 6 + ...jectLiteralMemberWithQuestionMark1.symbols | 5 + ...objectLiteralMemberWithQuestionMark1.types | 6 + .../objectLiteralMemberWithoutBlock1.symbols | 5 + .../objectLiteralMemberWithoutBlock1.types | 6 + .../objectLiteralParameterResolution.symbols | 57 + .../objectLiteralParameterResolution.types | 75 + ...teralReferencingInternalProperties.symbols | 6 + ...LiteralReferencingInternalProperties.types | 9 + ...ShorthandPropertiesAssignmentError.symbols | 40 + ...alShorthandPropertiesAssignmentError.types | 46 + ...signmentErrorFromMissingIdentifier.symbols | 43 + ...AssignmentErrorFromMissingIdentifier.types | 51 + ...iesErrorFromNoneExistingIdentifier.symbols | 11 + ...rtiesErrorFromNoneExistingIdentifier.types | 12 + ...pertiesErrorFromNotUsingIdentifier.symbols | 48 + ...ropertiesErrorFromNotUsingIdentifier.types | 68 + ...ShorthandPropertiesErrorWithModule.symbols | 30 + ...alShorthandPropertiesErrorWithModule.types | 40 + ...orthandPropertiesFunctionArgument2.symbols | 22 + ...ShorthandPropertiesFunctionArgument2.types | 26 + ...teralWithGetAccessorInsideFunction.symbols | 19 + ...LiteralWithGetAccessorInsideFunction.types | 21 + ...jectLiteralWithNumericPropertyName.symbols | 13 + ...objectLiteralWithNumericPropertyName.types | 16 + .../objectLiteralWithSemicolons1.symbols | 7 + .../objectLiteralWithSemicolons1.types | 10 + .../objectLiteralWithSemicolons2.symbols | 13 + .../objectLiteralWithSemicolons2.types | 16 + .../objectLiteralWithSemicolons3.symbols | 13 + .../objectLiteralWithSemicolons3.types | 17 + .../objectLiteralWithSemicolons4.symbols | 8 + .../objectLiteralWithSemicolons4.types | 11 + .../objectLiteralWithSemicolons5.symbols | 7 + .../objectLiteralWithSemicolons5.types | 9 + .../reference/objectRestNegative.symbols | 62 + .../reference/objectRestNegative.types | 72 + .../reference/objectSpreadNegative.symbols | 292 + .../reference/objectSpreadNegative.types | 402 + .../objectSpreadNegativeParse.symbols | 14 + .../reference/objectSpreadNegativeParse.types | 29 + .../reference/objectSpreadStrictNull.symbols | 144 + .../reference/objectSpreadStrictNull.types | 159 + ...tTypeHidingMembersOfExtendedObject.symbols | 158 + ...ectTypeHidingMembersOfExtendedObject.types | 177 + ...ingMembersOfObjectAssignmentCompat.symbols | 56 + ...idingMembersOfObjectAssignmentCompat.types | 64 + ...ngMembersOfObjectAssignmentCompat2.symbols | 56 + ...dingMembersOfObjectAssignmentCompat2.types | 65 + .../objectTypeLiteralSyntax2.symbols | 27 + .../reference/objectTypeLiteralSyntax2.types | 27 + ...gMembersOfFunctionAssignmentCompat.symbols | 36 + ...ingMembersOfFunctionAssignmentCompat.types | 40 + ...ctSignatureAppearsToBeFunctionType.symbols | 51 + ...ructSignatureAppearsToBeFunctionType.types | 55 + ...gMembersOfFunctionAssignmentCompat.symbols | 36 + ...ingMembersOfFunctionAssignmentCompat.types | 40 + ...ctTypeWithDuplicateNumericProperty.symbols | 41 + ...jectTypeWithDuplicateNumericProperty.types | 49 + .../objectTypeWithOptionalProperty1.symbols | 7 + .../objectTypeWithOptionalProperty1.types | 9 + ...ctTypeWithRecursiveWrappedProperty.symbols | 38 + ...jectTypeWithRecursiveWrappedProperty.types | 43 + ...tTypeWithRecursiveWrappedProperty2.symbols | 38 + ...ectTypeWithRecursiveWrappedProperty2.types | 43 + ...iveWrappedPropertyCheckedNominally.symbols | 166 + ...rsiveWrappedPropertyCheckedNominally.types | 189 + ...thStringIndexerHidingObjectIndexer.symbols | 67 + ...WithStringIndexerHidingObjectIndexer.types | 76 + ...TypeWithStringNamedNumericProperty.symbols | 48 +- ...ctTypesIdentityWithCallSignatures3.symbols | 120 + ...jectTypesIdentityWithCallSignatures3.types | 122 + .../objectTypesIdentityWithPrivates3.symbols | 62 + .../objectTypesIdentityWithPrivates3.types | 64 + .../objectTypesWithOptionalProperties.symbols | 48 + .../objectTypesWithOptionalProperties.types | 50 + ...objectTypesWithOptionalProperties2.symbols | 52 + .../objectTypesWithOptionalProperties2.types | 55 + ...jectTypesWithPredefinedTypesAsName.symbols | 20 + ...objectTypesWithPredefinedTypesAsName.types | 20 + ...ectTypesWithPredefinedTypesAsName2.symbols | 5 + ...bjectTypesWithPredefinedTypesAsName2.types | 7 + .../octalIntegerLiteralError.symbols | 16 + .../reference/octalIntegerLiteralError.types | 27 + .../octalLiteralInStrictModeES3.symbols | 4 + .../octalLiteralInStrictModeES3.types | 7 + .../operatorAddNullUndefined.symbols | 75 + .../reference/operatorAddNullUndefined.types | 109 + .../optionalArgsWithDefaultValues.symbols | 33 + .../optionalArgsWithDefaultValues.types | 44 + .../optionalBindingParameters1.symbols | 15 + .../optionalBindingParameters1.types | 25 + .../optionalBindingParameters2.symbols | 24 + .../optionalBindingParameters2.types | 34 + ...ionalBindingParametersInOverloads1.symbols | 19 + ...ptionalBindingParametersInOverloads1.types | 29 + ...ionalBindingParametersInOverloads2.symbols | 28 + ...ptionalBindingParametersInOverloads2.types | 38 + .../optionalFunctionArgAssignability.symbols | 49 + .../optionalFunctionArgAssignability.types | 54 + .../reference/optionalParamArgsTest.symbols | 383 + .../reference/optionalParamArgsTest.types | 529 + .../optionalParamAssignmentCompat.symbols | 38 + .../optionalParamAssignmentCompat.types | 38 + ...tionalParamReferencingOtherParams2.symbols | 17 + ...optionalParamReferencingOtherParams2.types | 19 + ...tionalParamReferencingOtherParams3.symbols | 14 + ...optionalParamReferencingOtherParams3.types | 14 + .../optionalParamTypeComparison.symbols | 19 + .../optionalParamTypeComparison.types | 21 + .../optionalParameterProperty.symbols | 20 + .../reference/optionalParameterProperty.types | 21 + ...nalParamterAndVariableDeclaration2.symbols | 13 + ...ionalParamterAndVariableDeclaration2.types | 16 + .../optionalPropertiesInClasses.symbols | 37 + .../optionalPropertiesInClasses.types | 37 + .../optionalPropertiesSyntax.symbols | 69 + .../reference/optionalPropertiesSyntax.types | 69 + .../reference/optionalPropertiesTest.symbols | 140 + .../reference/optionalPropertiesTest.types | 176 + .../reference/optionalSetterParam.symbols | 9 + .../reference/optionalSetterParam.types | 9 + .../optionsInlineSourceMapMapRoot.symbols | 4 + .../optionsInlineSourceMapMapRoot.types | 5 + .../optionsInlineSourceMapSourcemap.symbols | 4 + .../optionsInlineSourceMapSourcemap.types | 5 + .../optionsOutAndNoModuleGen.symbols | 4 + .../reference/optionsOutAndNoModuleGen.types | 5 + ...erMattersForSignatureGroupIdentity.symbols | 63 + ...rderMattersForSignatureGroupIdentity.types | 77 + tests/baselines/reference/out-flag2.symbols | 8 + tests/baselines/reference/out-flag2.types | 8 + tests/baselines/reference/out-flag3.symbols | 10 + tests/baselines/reference/out-flag3.types | 10 + .../reference/outModuleConcatCommonjs.symbols | 14 + .../reference/outModuleConcatCommonjs.types | 14 + .../reference/outModuleConcatES6.symbols | 14 + .../reference/outModuleConcatES6.types | 14 + .../reference/outModuleConcatUmd.symbols | 14 + .../reference/outModuleConcatUmd.types | 14 + ...tModuleConcatUnspecifiedModuleKind.symbols | 8 + ...outModuleConcatUnspecifiedModuleKind.types | 9 + .../overEagerReturnTypeSpecialization.symbols | 61 + .../overEagerReturnTypeSpecialization.types | 71 + tests/baselines/reference/overload1.symbols | 138 + tests/baselines/reference/overload1.types | 167 + .../overloadAssignmentCompat.symbols | 81 + .../reference/overloadAssignmentCompat.types | 94 + .../reference/overloadConsecutiveness.symbols | 31 + .../reference/overloadConsecutiveness.types | 31 + .../overloadModifiersMustAgree.symbols | 35 + .../overloadModifiersMustAgree.types | 35 + .../overloadOnConstInheritance2.symbols | 21 + .../overloadOnConstInheritance2.types | 21 + ...overloadOnConstNoAnyImplementation.symbols | 56 + .../overloadOnConstNoAnyImplementation.types | 78 + ...verloadOnConstNoAnyImplementation2.symbols | 72 + .../overloadOnConstNoAnyImplementation2.types | 96 + ...loadOnConstNoStringImplementation2.symbols | 73 + ...erloadOnConstNoStringImplementation2.types | 97 + ...verloadOnConstantsInvalidOverload1.symbols | 36 + .../overloadOnConstantsInvalidOverload1.types | 39 + .../reference/overloadResolution.symbols | 255 + .../reference/overloadResolution.types | 333 + ...verloadResolutionClassConstructors.symbols | 229 + .../overloadResolutionClassConstructors.types | 309 + .../overloadResolutionConstructors.symbols | 259 + .../overloadResolutionConstructors.types | 335 + ...oadResolutionOnDefaultConstructor1.symbols | 11 + ...rloadResolutionOnDefaultConstructor1.types | 13 + .../overloadResolutionOverCTLambda.symbols | 11 + .../overloadResolutionOverCTLambda.types | 13 + .../reference/overloadResolutionTest1.symbols | 92 + .../reference/overloadResolutionTest1.types | 120 + .../reference/overloadingOnConstants1.symbols | 106 + .../reference/overloadingOnConstants1.types | 122 + .../reference/overloadingOnConstants2.symbols | 89 + .../reference/overloadingOnConstants2.types | 111 + ...rloadingStaticFunctionsInFunctions.symbols | 8 + ...verloadingStaticFunctionsInFunctions.types | 22 + ...tionWithConstraintCheckingDeferred.symbols | 76 + ...lutionWithConstraintCheckingDeferred.types | 84 + ...verloadsAndTypeArgumentArityErrors.symbols | 22 + .../overloadsAndTypeArgumentArityErrors.types | 26 + ...fferentContainersDisagreeOnAmbient.symbols | 15 + ...DifferentContainersDisagreeOnAmbient.types | 15 + .../overloadsWithProvisionalErrors.symbols | 30 + .../overloadsWithProvisionalErrors.types | 45 + .../reference/overloadsWithinClasses.symbols | 45 + .../reference/overloadsWithinClasses.types | 45 + .../overridingPrivateStaticMembers.symbols | 18 + .../overridingPrivateStaticMembers.types | 18 + .../packageJsonMain_isNonRecursive.symbols | 4 + .../packageJsonMain_isNonRecursive.types | 4 + .../paramPropertiesInSignatures.symbols | 26 + .../paramPropertiesInSignatures.types | 26 + ...eterInitializersForwardReferencing.symbols | 121 + ...ameterInitializersForwardReferencing.types | 131 + .../parameterNamesInTypeParameterList.symbols | 64 + .../parameterNamesInTypeParameterList.types | 82 + .../parameterPropertyInConstructor1.symbols | 12 + .../parameterPropertyInConstructor1.types | 12 + .../parameterPropertyInConstructor2.symbols | 17 + .../parameterPropertyInConstructor2.types | 17 + ...arameterPropertyOutsideConstructor.symbols | 9 + .../parameterPropertyOutsideConstructor.types | 9 + .../parenthesizedContexualTyping1.symbols | 237 +- .../parenthesizedContexualTyping1.types | 43 +- .../parenthesizedContexualTyping2.types | 10 +- tests/baselines/reference/parse1.symbols | 11 + tests/baselines/reference/parse1.types | 14 + tests/baselines/reference/parse2.symbols | 7 + tests/baselines/reference/parse2.types | 8 + ...larationInStrictModeByDefaultInES6.symbols | 22 + ...eclarationInStrictModeByDefaultInES6.types | 25 + .../parseCommaSeperatedNewlineNew.symbols | 4 + .../parseCommaSeperatedNewlineNew.types | 10 + .../parseCommaSeperatedNewlineNumber.symbols | 4 + .../parseCommaSeperatedNewlineNumber.types | 9 + .../parseCommaSeperatedNewlineString.symbols | 4 + .../parseCommaSeperatedNewlineString.types | 9 + .../parseErrorInHeritageClause1.symbols | 4 + .../parseErrorInHeritageClause1.types | 5 + .../parseErrorIncorrectReturnToken.symbols | 31 + .../parseErrorIncorrectReturnToken.types | 42 + .../parseIncompleteBinaryExpression1.symbols | 4 + .../parseIncompleteBinaryExpression1.types | 7 + ...RegularExpressionMixedWithComments.symbols | 17 + ...seRegularExpressionMixedWithComments.types | 27 + tests/baselines/reference/parseTypes.symbols | 41 + tests/baselines/reference/parseTypes.types | 56 + ...syncGenerators.classMethods.esnext.symbols | 256 + ....asyncGenerators.classMethods.esnext.types | 289 + ...rators.functionDeclarations.esnext.symbols | 139 + ...nerators.functionDeclarations.esnext.types | 167 + ...erators.functionExpressions.esnext.symbols | 153 + ...enerators.functionExpressions.esnext.types | 211 + ...rators.objectLiteralMethods.esnext.symbols | 252 + ...nerators.objectLiteralMethods.esnext.types | 308 + .../reference/parser.forAwait.esnext.symbols | 114 + .../reference/parser.forAwait.esnext.types | 120 + .../reference/parser0_004152.symbols | 11 + .../baselines/reference/parser0_004152.types | 15 + .../reference/parser10.1.1-8gs.symbols | 20 + .../reference/parser10.1.1-8gs.types | 27 + .../reference/parser15.4.4.14-9-2.symbols | 51 + .../reference/parser15.4.4.14-9-2.types | 115 + .../baselines/reference/parser509534.symbols | 23 + tests/baselines/reference/parser509534.types | 49 + .../baselines/reference/parser509618.symbols | 8 + tests/baselines/reference/parser509618.types | 8 + .../baselines/reference/parser509630.symbols | 12 + tests/baselines/reference/parser509630.types | 13 + .../baselines/reference/parser509667.symbols | 19 + tests/baselines/reference/parser509667.types | 22 + .../baselines/reference/parser509668.symbols | 8 + tests/baselines/reference/parser509668.types | 8 + .../baselines/reference/parser509669.symbols | 6 + tests/baselines/reference/parser509669.types | 7 + .../baselines/reference/parser509693.symbols | 3 + tests/baselines/reference/parser509693.types | 12 + .../baselines/reference/parser509698.symbols | 8 + tests/baselines/reference/parser509698.types | 8 + .../baselines/reference/parser512084.symbols | 4 + tests/baselines/reference/parser512084.types | 4 + .../baselines/reference/parser512097.symbols | 7 + tests/baselines/reference/parser512097.types | 10 + .../baselines/reference/parser512325.symbols | 4 + tests/baselines/reference/parser512325.types | 16 + .../baselines/reference/parser519458.symbols | 6 + tests/baselines/reference/parser519458.types | 12 + .../baselines/reference/parser521128.symbols | 3 + tests/baselines/reference/parser521128.types | 6 + .../baselines/reference/parser536727.symbols | 30 + tests/baselines/reference/parser536727.types | 40 + .../baselines/reference/parser553699.symbols | 17 + tests/baselines/reference/parser553699.types | 18 + .../baselines/reference/parser566700.symbols | 4 + tests/baselines/reference/parser566700.types | 8 + .../baselines/reference/parser585151.symbols | 8 + tests/baselines/reference/parser585151.types | 9 + .../baselines/reference/parser618973.symbols | 8 + tests/baselines/reference/parser618973.types | 8 + .../baselines/reference/parser642331.symbols | 8 + tests/baselines/reference/parser642331.types | 8 + .../reference/parser642331_1.symbols | 10 + .../baselines/reference/parser642331_1.types | 11 + .../reference/parser645086_1.symbols | 4 + .../baselines/reference/parser645086_1.types | 6 + .../reference/parser645086_2.symbols | 4 + .../baselines/reference/parser645086_2.types | 6 + .../parserAccessibilityAfterStatic1.symbols | 8 + .../parserAccessibilityAfterStatic1.types | 8 + .../parserAccessibilityAfterStatic10.symbols | 9 + .../parserAccessibilityAfterStatic10.types | 9 + .../parserAccessibilityAfterStatic6.symbols | 7 + .../parserAccessibilityAfterStatic6.types | 7 + .../parserAccessibilityAfterStatic7.symbols | 8 + .../parserAccessibilityAfterStatic7.types | 8 + .../reference/parserAccessors1.symbols | 7 + .../reference/parserAccessors1.types | 7 + .../reference/parserAccessors10.symbols | 8 + .../reference/parserAccessors10.types | 9 + .../reference/parserAccessors3.symbols | 5 + .../reference/parserAccessors3.types | 6 + .../reference/parserAccessors5.symbols | 7 + .../reference/parserAccessors5.types | 8 + .../reference/parserAccessors6.symbols | 8 + .../reference/parserAccessors6.types | 8 + .../reference/parserAccessors7.symbols | 6 + .../reference/parserAccessors7.types | 7 + .../reference/parserAccessors8.symbols | 5 + .../reference/parserAccessors8.types | 6 + .../reference/parserAccessors9.symbols | 7 + .../reference/parserAccessors9.types | 8 + .../parserAdditiveExpression1.symbols | 3 + .../reference/parserAdditiveExpression1.types | 14 + .../reference/parserAmbiguity1.symbols | 3 + .../reference/parserAmbiguity1.types | 10 + .../reference/parserAmbiguity2.symbols | 3 + .../reference/parserAmbiguity2.types | 11 + .../reference/parserAmbiguity3.symbols | 3 + .../reference/parserAmbiguity3.types | 13 + ...parserAmbiguityWithBinaryOperator4.symbols | 13 + .../parserAmbiguityWithBinaryOperator4.types | 18 + .../reference/parserArgumentList1.symbols | 21 + .../reference/parserArgumentList1.types | 43 + .../parserArrowFunctionExpression1.symbols | 5 + .../parserArrowFunctionExpression1.types | 6 + .../parserArrowFunctionExpression2.symbols | 3 + .../parserArrowFunctionExpression2.types | 9 + .../parserArrowFunctionExpression3.symbols | 3 + .../parserArrowFunctionExpression3.types | 9 + .../parserArrowFunctionExpression4.symbols | 3 + .../parserArrowFunctionExpression4.types | 9 + .../parserArrowFunctionExpression5.symbols | 21 +- .../parserArrowFunctionExpression5.types | 33 +- .../parserAssignmentExpression1.symbols | 3 + .../parserAssignmentExpression1.types | 8 + .../reference/parserAstSpans1.symbols | 640 + .../baselines/reference/parserAstSpans1.types | 721 + ...parserAutomaticSemicolonInsertion1.symbols | 36 + .../parserAutomaticSemicolonInsertion1.types | 40 + .../reference/parserBlockStatement1.d.symbols | 3 + .../reference/parserBlockStatement1.d.types | 3 + .../reference/parserBreakStatement1.d.symbols | 3 + .../reference/parserBreakStatement1.d.types | 3 + .../parserCastVersusArrowFunction1.symbols | 34 + .../parserCastVersusArrowFunction1.types | 67 + ...rserCatchClauseWithTypeAnnotation1.symbols | 7 + ...parserCatchClauseWithTypeAnnotation1.types | 7 + .../baselines/reference/parserClass1.symbols | 24 + tests/baselines/reference/parserClass1.types | 30 + .../baselines/reference/parserClass2.symbols | 14 + tests/baselines/reference/parserClass2.types | 22 + .../reference/parserClassDeclaration1.symbols | 4 + .../reference/parserClassDeclaration1.types | 6 + .../parserClassDeclaration10.symbols | 8 + .../reference/parserClassDeclaration10.types | 8 + .../parserClassDeclaration11.symbols | 8 + .../reference/parserClassDeclaration11.types | 8 + .../parserClassDeclaration12.symbols | 8 + .../reference/parserClassDeclaration12.types | 8 + .../parserClassDeclaration13.symbols | 10 + .../reference/parserClassDeclaration13.types | 10 + .../parserClassDeclaration14.symbols | 9 + .../reference/parserClassDeclaration14.types | 9 + .../parserClassDeclaration15.symbols | 9 + .../reference/parserClassDeclaration15.types | 9 + .../parserClassDeclaration18.symbols | 16 + .../reference/parserClassDeclaration18.types | 16 + .../reference/parserClassDeclaration2.symbols | 4 + .../reference/parserClassDeclaration2.types | 6 + .../parserClassDeclaration21.symbols | 7 + .../reference/parserClassDeclaration21.types | 7 + .../parserClassDeclaration22.symbols | 7 + .../reference/parserClassDeclaration22.types | 7 + .../parserClassDeclaration24.symbols | 4 + .../reference/parserClassDeclaration24.types | 4 + .../parserClassDeclaration25.symbols | 26 + .../reference/parserClassDeclaration25.types | 26 + .../reference/parserClassDeclaration3.symbols | 4 + .../reference/parserClassDeclaration3.types | 6 + .../reference/parserClassDeclaration4.symbols | 5 + .../reference/parserClassDeclaration4.types | 7 + .../reference/parserClassDeclaration5.symbols | 5 + .../reference/parserClassDeclaration5.types | 7 + .../reference/parserClassDeclaration6.symbols | 4 + .../reference/parserClassDeclaration6.types | 6 + .../reference/parserClassDeclaration7.symbols | 8 + .../reference/parserClassDeclaration7.types | 8 + .../reference/parserClassDeclaration8.symbols | 6 + .../reference/parserClassDeclaration8.types | 6 + .../reference/parserClassDeclaration9.symbols | 7 + .../reference/parserClassDeclaration9.types | 7 + .../parserCommaInTypeMemberList2.symbols | 8 + .../parserCommaInTypeMemberList2.types | 17 + .../parserComputedPropertyName1.symbols | 4 + .../parserComputedPropertyName1.types | 7 + .../parserComputedPropertyName10.symbols | 6 + .../parserComputedPropertyName10.types | 8 + .../parserComputedPropertyName11.symbols | 6 + .../parserComputedPropertyName11.types | 7 + .../parserComputedPropertyName12.symbols | 6 + .../parserComputedPropertyName12.types | 7 + .../parserComputedPropertyName13.symbols | 4 + .../parserComputedPropertyName13.types | 5 + .../parserComputedPropertyName14.symbols | 4 + .../parserComputedPropertyName14.types | 5 + .../parserComputedPropertyName15.symbols | 5 + .../parserComputedPropertyName15.types | 6 + .../parserComputedPropertyName16.symbols | 6 + .../parserComputedPropertyName16.types | 8 + .../parserComputedPropertyName17.symbols | 5 + .../parserComputedPropertyName17.types | 7 + .../parserComputedPropertyName18.symbols | 4 + .../parserComputedPropertyName18.types | 5 + .../parserComputedPropertyName19.symbols | 4 + .../parserComputedPropertyName19.types | 5 + .../parserComputedPropertyName2.symbols | 4 + .../parserComputedPropertyName2.types | 7 + .../parserComputedPropertyName20.symbols | 6 + .../parserComputedPropertyName20.types | 7 + .../parserComputedPropertyName21.symbols | 6 + .../parserComputedPropertyName21.types | 7 + .../parserComputedPropertyName22.symbols | 6 + .../parserComputedPropertyName22.types | 7 + .../parserComputedPropertyName23.symbols | 6 + .../parserComputedPropertyName23.types | 7 + .../parserComputedPropertyName24.symbols | 7 + .../parserComputedPropertyName24.types | 8 + .../parserComputedPropertyName25.symbols | 8 + .../parserComputedPropertyName25.types | 15 + .../parserComputedPropertyName26.symbols | 8 + .../parserComputedPropertyName26.types | 15 + .../parserComputedPropertyName27.symbols | 9 + .../parserComputedPropertyName27.types | 14 + .../parserComputedPropertyName28.symbols | 7 + .../parserComputedPropertyName28.types | 11 + .../parserComputedPropertyName29.symbols | 8 + .../parserComputedPropertyName29.types | 13 + .../parserComputedPropertyName3.symbols | 4 + .../parserComputedPropertyName3.types | 6 + .../parserComputedPropertyName30.symbols | 8 + .../parserComputedPropertyName30.types | 14 + .../parserComputedPropertyName31.symbols | 8 + .../parserComputedPropertyName31.types | 11 + .../parserComputedPropertyName32.symbols | 6 + .../parserComputedPropertyName32.types | 7 + .../parserComputedPropertyName33.symbols | 8 + .../parserComputedPropertyName33.types | 14 + .../parserComputedPropertyName34.symbols | 8 + .../parserComputedPropertyName34.types | 14 + .../parserComputedPropertyName35.symbols | 6 + .../parserComputedPropertyName35.types | 11 + .../parserComputedPropertyName36.symbols | 6 + .../parserComputedPropertyName36.types | 7 + .../parserComputedPropertyName37.symbols | 6 + .../parserComputedPropertyName37.types | 10 + .../parserComputedPropertyName38.symbols | 6 + .../parserComputedPropertyName38.types | 7 + .../parserComputedPropertyName39.symbols | 7 + .../parserComputedPropertyName39.types | 10 + .../parserComputedPropertyName4.symbols | 4 + .../parserComputedPropertyName4.types | 6 + .../parserComputedPropertyName40.symbols | 6 + .../parserComputedPropertyName40.types | 10 + .../parserComputedPropertyName41.symbols | 6 + .../parserComputedPropertyName41.types | 11 + .../parserComputedPropertyName5.symbols | 4 + .../parserComputedPropertyName5.types | 6 + .../parserComputedPropertyName6.symbols | 4 + .../parserComputedPropertyName6.types | 11 + .../parserComputedPropertyName7.symbols | 6 + .../parserComputedPropertyName7.types | 7 + .../parserComputedPropertyName8.symbols | 6 + .../parserComputedPropertyName8.types | 7 + .../parserComputedPropertyName9.symbols | 6 + .../parserComputedPropertyName9.types | 8 + .../parserConditionalExpression1.symbols | 3 + .../parserConditionalExpression1.types | 34 + .../parserConstructorAmbiguity1.symbols | 4 + .../parserConstructorAmbiguity1.types | 7 + .../parserConstructorAmbiguity2.symbols | 4 + .../parserConstructorAmbiguity2.types | 7 + .../parserConstructorAmbiguity3.symbols | 4 + .../parserConstructorAmbiguity3.types | 6 + .../parserConstructorAmbiguity4.symbols | 4 + .../parserConstructorAmbiguity4.types | 10 + .../parserConstructorDeclaration10.symbols | 6 + .../parserConstructorDeclaration10.types | 6 + .../parserConstructorDeclaration11.symbols | 6 + .../parserConstructorDeclaration11.types | 6 + .../parserConstructorDeclaration12.symbols | 13 + .../parserConstructorDeclaration12.types | 13 + .../parserConstructorDeclaration2.symbols | 6 + .../parserConstructorDeclaration2.types | 6 + .../parserConstructorDeclaration3.symbols | 6 + .../parserConstructorDeclaration3.types | 6 + .../parserConstructorDeclaration4.symbols | 6 + .../parserConstructorDeclaration4.types | 6 + .../parserConstructorDeclaration6.symbols | 6 + .../parserConstructorDeclaration6.types | 6 + .../parserConstructorDeclaration7.symbols | 6 + .../parserConstructorDeclaration7.types | 6 + .../parserConstructorDeclaration8.symbols | 7 + .../parserConstructorDeclaration8.types | 7 + .../parserConstructorDeclaration9.symbols | 7 + .../parserConstructorDeclaration9.types | 7 + .../parserContinueStatement1.d.symbols | 3 + .../parserContinueStatement1.d.types | 3 + .../parserDebuggerStatement1.d.symbols | 3 + .../parserDebuggerStatement1.d.types | 3 + .../reference/parserDoStatement1.d.symbols | 5 + .../reference/parserDoStatement1.d.types | 6 + .../reference/parserES3Accessors1.symbols | 7 + .../reference/parserES3Accessors1.types | 7 + .../reference/parserES3Accessors2.symbols | 8 + .../reference/parserES3Accessors2.types | 8 + .../reference/parserES3Accessors3.symbols | 5 + .../reference/parserES3Accessors3.types | 6 + .../reference/parserES3Accessors4.symbols | 6 + .../reference/parserES3Accessors4.types | 7 + .../parserES5ComputedPropertyName1.symbols | 6 + .../parserES5ComputedPropertyName1.types | 7 + .../parserES5ComputedPropertyName10.symbols | 6 + .../parserES5ComputedPropertyName10.types | 8 + .../parserES5ComputedPropertyName11.symbols | 6 + .../parserES5ComputedPropertyName11.types | 7 + .../parserES5ComputedPropertyName2.symbols | 4 + .../parserES5ComputedPropertyName2.types | 7 + .../parserES5ComputedPropertyName3.symbols | 4 + .../parserES5ComputedPropertyName3.types | 6 + .../parserES5ComputedPropertyName4.symbols | 4 + .../parserES5ComputedPropertyName4.types | 6 + .../parserES5ComputedPropertyName5.symbols | 6 + .../parserES5ComputedPropertyName5.types | 7 + .../parserES5ComputedPropertyName6.symbols | 6 + .../parserES5ComputedPropertyName6.types | 8 + .../parserES5ComputedPropertyName7.symbols | 6 + .../parserES5ComputedPropertyName7.types | 7 + .../parserES5ComputedPropertyName8.symbols | 4 + .../parserES5ComputedPropertyName8.types | 5 + .../parserES5ComputedPropertyName9.symbols | 6 + .../parserES5ComputedPropertyName9.types | 8 + .../parserES5ForOfStatement1.d.symbols | 4 + .../parserES5ForOfStatement1.d.types | 5 + .../parserES5ForOfStatement10.symbols | 4 + .../reference/parserES5ForOfStatement10.types | 5 + .../parserES5ForOfStatement11.symbols | 5 + .../reference/parserES5ForOfStatement11.types | 6 + .../parserES5ForOfStatement12.symbols | 5 + .../reference/parserES5ForOfStatement12.types | 6 + .../parserES5ForOfStatement13.symbols | 5 + .../reference/parserES5ForOfStatement13.types | 6 + .../parserES5ForOfStatement14.symbols | 5 + .../reference/parserES5ForOfStatement14.types | 6 + .../parserES5ForOfStatement15.symbols | 5 + .../reference/parserES5ForOfStatement15.types | 6 + .../parserES5ForOfStatement16.symbols | 5 + .../reference/parserES5ForOfStatement16.types | 6 + .../parserES5ForOfStatement2.symbols | 4 + .../reference/parserES5ForOfStatement2.types | 4 + .../parserES5ForOfStatement20.symbols | 5 + .../reference/parserES5ForOfStatement20.types | 6 + .../parserES5ForOfStatement21.symbols | 3 + .../reference/parserES5ForOfStatement21.types | 4 + .../parserES5ForOfStatement3.symbols | 5 + .../reference/parserES5ForOfStatement3.types | 6 + .../parserES5ForOfStatement4.symbols | 4 + .../reference/parserES5ForOfStatement4.types | 6 + .../parserES5ForOfStatement5.symbols | 4 + .../reference/parserES5ForOfStatement5.types | 5 + .../parserES5ForOfStatement6.symbols | 5 + .../reference/parserES5ForOfStatement6.types | 8 + .../parserES5ForOfStatement7.symbols | 5 + .../reference/parserES5ForOfStatement7.types | 8 + .../parserES5ForOfStatement8.symbols | 4 + .../reference/parserES5ForOfStatement8.types | 5 + .../parserES5ForOfStatement9.symbols | 4 + .../reference/parserES5ForOfStatement9.types | 5 + .../reference/parserES5SymbolIndexer1.symbols | 7 + .../reference/parserES5SymbolIndexer1.types | 7 + .../reference/parserES5SymbolIndexer2.symbols | 7 + .../reference/parserES5SymbolIndexer2.types | 7 + .../reference/parserES5SymbolIndexer3.symbols | 7 + .../reference/parserES5SymbolIndexer3.types | 7 + .../parserES5SymbolProperty1.symbols | 6 + .../reference/parserES5SymbolProperty1.types | 9 + .../parserES5SymbolProperty2.symbols | 6 + .../reference/parserES5SymbolProperty2.types | 9 + .../parserES5SymbolProperty3.symbols | 6 + .../reference/parserES5SymbolProperty3.types | 9 + .../parserES5SymbolProperty4.symbols | 6 + .../reference/parserES5SymbolProperty4.types | 9 + .../parserES5SymbolProperty5.symbols | 6 + .../reference/parserES5SymbolProperty5.types | 9 + .../parserES5SymbolProperty6.symbols | 6 + .../reference/parserES5SymbolProperty6.types | 10 + .../parserES5SymbolProperty7.symbols | 6 + .../reference/parserES5SymbolProperty7.types | 9 + .../parserES5SymbolProperty8.symbols | 6 + .../reference/parserES5SymbolProperty8.types | 9 + .../parserES5SymbolProperty9.symbols | 6 + .../reference/parserES5SymbolProperty9.types | 9 + ...arserEmptyParenthesizedExpression1.symbols | 6 + .../parserEmptyParenthesizedExpression1.types | 11 + .../reference/parserEmptyStatement1.d.symbols | 3 + .../reference/parserEmptyStatement1.d.types | 3 + tests/baselines/reference/parserEnum4.symbols | 6 + tests/baselines/reference/parserEnum4.types | 6 + tests/baselines/reference/parserEnum5.symbols | 16 + tests/baselines/reference/parserEnum5.types | 17 + tests/baselines/reference/parserEnum7.symbols | 6 + tests/baselines/reference/parserEnum7.types | 6 + .../reference/parserEnumDeclaration2.symbols | 8 + .../reference/parserEnumDeclaration2.types | 8 + .../parserEnumDeclaration3.d.symbols | 7 + .../reference/parserEnumDeclaration3.d.types | 8 + .../reference/parserEnumDeclaration4.symbols | 4 + .../reference/parserEnumDeclaration4.types | 6 + ...serEqualsGreaterThanAfterFunction1.symbols | 4 + ...arserEqualsGreaterThanAfterFunction1.types | 4 + ...serEqualsGreaterThanAfterFunction2.symbols | 6 + ...arserEqualsGreaterThanAfterFunction2.types | 6 + ...rantAccessibilityModifierInModule1.symbols | 13 + ...ErrantAccessibilityModifierInModule1.types | 17 + ...antEqualsGreaterThanAfterFunction1.symbols | 4 + ...rrantEqualsGreaterThanAfterFunction1.types | 5 + ...antEqualsGreaterThanAfterFunction2.symbols | 5 + ...rrantEqualsGreaterThanAfterFunction2.types | 7 + .../parserErrantSemicolonInClass1.symbols | 67 + .../parserErrantSemicolonInClass1.types | 75 + ...rorRecoveryArrayLiteralExpression1.symbols | 5 + ...ErrorRecoveryArrayLiteralExpression1.types | 14 + ...rorRecoveryArrayLiteralExpression2.symbols | 6 + ...ErrorRecoveryArrayLiteralExpression2.types | 18 + ...rorRecoveryArrayLiteralExpression3.symbols | 4 + ...ErrorRecoveryArrayLiteralExpression3.types | 14 + .../parserErrorRecoveryIfStatement1.symbols | 16 + .../parserErrorRecoveryIfStatement1.types | 19 + .../parserErrorRecoveryIfStatement2.symbols | 16 + .../parserErrorRecoveryIfStatement2.types | 19 + .../parserErrorRecoveryIfStatement3.symbols | 16 + .../parserErrorRecoveryIfStatement3.types | 21 + .../parserErrorRecoveryIfStatement4.symbols | 16 + .../parserErrorRecoveryIfStatement4.types | 21 + .../parserErrorRecoveryIfStatement5.symbols | 14 + .../parserErrorRecoveryIfStatement5.types | 21 + .../parserErrorRecoveryIfStatement6.symbols | 17 + .../parserErrorRecoveryIfStatement6.types | 20 + .../parserErrorRecovery_ArgumentList1.symbols | 7 + .../parserErrorRecovery_ArgumentList1.types | 11 + .../parserErrorRecovery_ArgumentList2.symbols | 6 + .../parserErrorRecovery_ArgumentList2.types | 8 + .../parserErrorRecovery_ArgumentList3.symbols | 7 + .../parserErrorRecovery_ArgumentList3.types | 11 + .../parserErrorRecovery_ArgumentList4.symbols | 7 + .../parserErrorRecovery_ArgumentList4.types | 12 + .../parserErrorRecovery_ArgumentList6.symbols | 3 + .../parserErrorRecovery_ArgumentList6.types | 6 + .../parserErrorRecovery_ArgumentList7.symbols | 3 + .../parserErrorRecovery_ArgumentList7.types | 7 + .../parserErrorRecovery_Block1.symbols | 7 + .../parserErrorRecovery_Block1.types | 11 + .../parserErrorRecovery_Block2.symbols | 7 + .../parserErrorRecovery_Block2.types | 7 + .../parserErrorRecovery_Block3.symbols | 11 + .../parserErrorRecovery_Block3.types | 11 + .../parserErrorRecovery_ClassElement1.symbols | 9 + .../parserErrorRecovery_ClassElement1.types | 9 + .../parserErrorRecovery_ClassElement2.symbols | 11 + .../parserErrorRecovery_ClassElement2.types | 11 + .../parserErrorRecovery_ClassElement3.symbols | 13 + .../parserErrorRecovery_ClassElement3.types | 14 + .../parserErrorRecovery_Expression1.symbols | 4 + .../parserErrorRecovery_Expression1.types | 8 + ...ecovery_ExtendsOrImplementsClause1.symbols | 4 + ...rRecovery_ExtendsOrImplementsClause1.types | 4 + ...ecovery_ExtendsOrImplementsClause2.symbols | 4 + ...rRecovery_ExtendsOrImplementsClause2.types | 5 + ...ecovery_ExtendsOrImplementsClause3.symbols | 4 + ...rRecovery_ExtendsOrImplementsClause3.types | 5 + ...ecovery_ExtendsOrImplementsClause4.symbols | 4 + ...rRecovery_ExtendsOrImplementsClause4.types | 5 + ...ecovery_ExtendsOrImplementsClause5.symbols | 4 + ...rRecovery_ExtendsOrImplementsClause5.types | 6 + ...ecovery_ExtendsOrImplementsClause6.symbols | 4 + ...rRecovery_ExtendsOrImplementsClause6.types | 4 + ...Recovery_IncompleteMemberVariable2.symbols | 67 + ...orRecovery_IncompleteMemberVariable2.types | 80 + .../parserErrorRecovery_LeftShift1.symbols | 3 + .../parserErrorRecovery_LeftShift1.types | 10 + ...parserErrorRecovery_ModuleElement1.symbols | 6 + .../parserErrorRecovery_ModuleElement1.types | 7 + ...parserErrorRecovery_ModuleElement2.symbols | 11 + .../parserErrorRecovery_ModuleElement2.types | 11 + ...parserErrorRecovery_ObjectLiteral1.symbols | 6 + .../parserErrorRecovery_ObjectLiteral1.types | 9 + ...parserErrorRecovery_ObjectLiteral2.symbols | 8 + .../parserErrorRecovery_ObjectLiteral2.types | 11 + ...parserErrorRecovery_ObjectLiteral3.symbols | 8 + .../parserErrorRecovery_ObjectLiteral3.types | 11 + ...parserErrorRecovery_ObjectLiteral4.symbols | 8 + .../parserErrorRecovery_ObjectLiteral4.types | 11 + ...parserErrorRecovery_ObjectLiteral5.symbols | 8 + .../parserErrorRecovery_ObjectLiteral5.types | 11 + ...parserErrorRecovery_ParameterList1.symbols | 5 + .../parserErrorRecovery_ParameterList1.types | 5 + ...parserErrorRecovery_ParameterList2.symbols | 5 + .../parserErrorRecovery_ParameterList2.types | 5 + ...parserErrorRecovery_ParameterList4.symbols | 5 + .../parserErrorRecovery_ParameterList4.types | 5 + ...parserErrorRecovery_ParameterList5.symbols | 4 + .../parserErrorRecovery_ParameterList5.types | 6 + ...parserErrorRecovery_ParameterList6.symbols | 8 + .../parserErrorRecovery_ParameterList6.types | 10 + .../parserErrorRecovery_SourceUnit1.symbols | 8 + .../parserErrorRecovery_SourceUnit1.types | 8 + ...rserErrorRecovery_SwitchStatement1.symbols | 9 + ...parserErrorRecovery_SwitchStatement1.types | 22 + ...rserErrorRecovery_SwitchStatement2.symbols | 10 + ...parserErrorRecovery_SwitchStatement2.types | 11 + .../parserErrorRecovery_VariableList1.symbols | 5 + .../parserErrorRecovery_VariableList1.types | 5 + .../reference/parserExportAssignment1.symbols | 3 + .../reference/parserExportAssignment1.types | 4 + .../reference/parserExportAssignment2.symbols | 3 + .../reference/parserExportAssignment2.types | 4 + .../reference/parserExportAssignment3.symbols | 3 + .../reference/parserExportAssignment3.types | 4 + .../reference/parserExportAssignment4.symbols | 3 + .../reference/parserExportAssignment4.types | 4 + .../reference/parserExportAssignment5.symbols | 6 + .../reference/parserExportAssignment5.types | 7 + .../reference/parserExportAssignment6.symbols | 5 + .../reference/parserExportAssignment6.types | 5 + .../reference/parserExportAssignment7.symbols | 6 + .../reference/parserExportAssignment7.types | 8 + .../reference/parserExportAssignment8.symbols | 6 + .../reference/parserExportAssignment8.types | 7 + .../reference/parserExportAssignment9.symbols | 12 + .../reference/parserExportAssignment9.types | 14 + .../parserExpressionStatement1.d.symbols | 3 + .../parserExpressionStatement1.d.types | 5 + .../reference/parserForInStatement1.d.symbols | 4 + .../reference/parserForInStatement1.d.types | 5 + .../reference/parserForInStatement2.symbols | 4 + .../reference/parserForInStatement2.types | 4 + .../reference/parserForInStatement3.symbols | 5 + .../reference/parserForInStatement3.types | 6 + .../reference/parserForInStatement4.symbols | 4 + .../reference/parserForInStatement4.types | 6 + .../reference/parserForInStatement5.symbols | 4 + .../reference/parserForInStatement5.types | 5 + .../reference/parserForInStatement6.symbols | 5 + .../reference/parserForInStatement6.types | 8 + .../reference/parserForInStatement7.symbols | 5 + .../reference/parserForInStatement7.types | 8 + .../reference/parserForOfStatement1.d.symbols | 4 + .../reference/parserForOfStatement1.d.types | 5 + .../reference/parserForOfStatement10.symbols | 4 + .../reference/parserForOfStatement10.types | 5 + .../reference/parserForOfStatement11.symbols | 5 + .../reference/parserForOfStatement11.types | 6 + .../reference/parserForOfStatement12.symbols | 5 + .../reference/parserForOfStatement12.types | 6 + .../reference/parserForOfStatement13.symbols | 5 + .../reference/parserForOfStatement13.types | 6 + .../reference/parserForOfStatement14.symbols | 5 + .../reference/parserForOfStatement14.types | 6 + .../reference/parserForOfStatement15.symbols | 5 + .../reference/parserForOfStatement15.types | 6 + .../reference/parserForOfStatement16.symbols | 5 + .../reference/parserForOfStatement16.types | 6 + .../reference/parserForOfStatement2.symbols | 4 + .../reference/parserForOfStatement2.types | 4 + .../reference/parserForOfStatement20.symbols | 5 + .../reference/parserForOfStatement20.types | 6 + .../reference/parserForOfStatement21.symbols | 3 + .../reference/parserForOfStatement21.types | 4 + .../reference/parserForOfStatement3.symbols | 5 + .../reference/parserForOfStatement3.types | 6 + .../reference/parserForOfStatement4.symbols | 4 + .../reference/parserForOfStatement4.types | 6 + .../reference/parserForOfStatement5.symbols | 4 + .../reference/parserForOfStatement5.types | 5 + .../reference/parserForOfStatement6.symbols | 5 + .../reference/parserForOfStatement6.types | 8 + .../reference/parserForOfStatement7.symbols | 5 + .../reference/parserForOfStatement7.types | 8 + .../reference/parserForOfStatement8.symbols | 4 + .../reference/parserForOfStatement8.types | 5 + .../reference/parserForOfStatement9.symbols | 4 + .../reference/parserForOfStatement9.types | 5 + .../reference/parserForStatement1.d.symbols | 4 + .../reference/parserForStatement1.d.types | 4 + .../reference/parserForStatement2.symbols | 18 + .../reference/parserForStatement2.types | 26 + .../reference/parserForStatement3.symbols | 3 + .../reference/parserForStatement3.types | 19 + .../reference/parserForStatement4.symbols | 4 + .../reference/parserForStatement4.types | 7 + .../reference/parserForStatement5.symbols | 4 + .../reference/parserForStatement5.types | 5 + .../reference/parserForStatement6.symbols | 4 + .../reference/parserForStatement6.types | 6 + .../reference/parserForStatement7.symbols | 4 + .../reference/parserForStatement7.types | 6 + .../reference/parserForStatement8.symbols | 4 + .../reference/parserForStatement8.types | 5 + .../parserFunctionDeclaration1.symbols | 7 + .../parserFunctionDeclaration1.types | 7 + .../parserFunctionDeclaration2.d.symbols | 4 + .../parserFunctionDeclaration2.d.types | 4 + .../parserFunctionDeclaration2.symbols | 4 + .../parserFunctionDeclaration2.types | 4 + .../parserFunctionDeclaration3.symbols | 4 + .../parserFunctionDeclaration3.types | 4 + .../parserFunctionDeclaration4.symbols | 7 + .../parserFunctionDeclaration4.types | 7 + .../parserFunctionDeclaration6.symbols | 8 + .../parserFunctionDeclaration6.types | 8 + .../parserFunctionDeclaration7.symbols | 7 + .../parserFunctionDeclaration7.types | 7 + tests/baselines/reference/parserFuzz1.symbols | 4 + tests/baselines/reference/parserFuzz1.types | 9 + .../parserGenericConstraint2.symbols | 6 + .../reference/parserGenericConstraint2.types | 7 + .../parserGenericConstraint3.symbols | 6 + .../reference/parserGenericConstraint3.types | 7 + .../parserGenericConstraint4.symbols | 6 + .../reference/parserGenericConstraint4.types | 8 + .../parserGenericConstraint5.symbols | 6 + .../reference/parserGenericConstraint5.types | 8 + .../parserGenericConstraint6.symbols | 6 + .../reference/parserGenericConstraint6.types | 8 + .../parserGenericConstraint7.symbols | 6 + .../reference/parserGenericConstraint7.types | 8 + ...serGenericsInInterfaceDeclaration1.symbols | 25 + ...arserGenericsInInterfaceDeclaration1.types | 26 + .../parserGenericsInTypeContexts1.symbols | 32 + .../parserGenericsInTypeContexts1.types | 53 + .../parserGenericsInTypeContexts2.symbols | 32 + .../parserGenericsInTypeContexts2.types | 89 + ...rserGenericsInVariableDeclaration1.symbols | 19 + ...parserGenericsInVariableDeclaration1.types | 43 + ...rserGetAccessorWithTypeParameters1.symbols | 8 + ...parserGetAccessorWithTypeParameters1.types | 8 + .../parserGreaterThanTokenAmbiguity11.symbols | 3 + .../parserGreaterThanTokenAmbiguity11.types | 6 + .../parserGreaterThanTokenAmbiguity12.symbols | 3 + .../parserGreaterThanTokenAmbiguity12.types | 7 + .../parserGreaterThanTokenAmbiguity13.symbols | 3 + .../parserGreaterThanTokenAmbiguity13.types | 7 + .../parserGreaterThanTokenAmbiguity14.symbols | 4 + .../parserGreaterThanTokenAmbiguity14.types | 9 + .../parserGreaterThanTokenAmbiguity15.symbols | 6 + .../parserGreaterThanTokenAmbiguity15.types | 10 + .../parserGreaterThanTokenAmbiguity16.symbols | 3 + .../parserGreaterThanTokenAmbiguity16.types | 6 + .../parserGreaterThanTokenAmbiguity17.symbols | 3 + .../parserGreaterThanTokenAmbiguity17.types | 7 + .../parserGreaterThanTokenAmbiguity18.symbols | 3 + .../parserGreaterThanTokenAmbiguity18.types | 7 + .../parserGreaterThanTokenAmbiguity19.symbols | 4 + .../parserGreaterThanTokenAmbiguity19.types | 9 + .../parserGreaterThanTokenAmbiguity2.symbols | 3 + .../parserGreaterThanTokenAmbiguity2.types | 8 + .../parserGreaterThanTokenAmbiguity20.symbols | 6 + .../parserGreaterThanTokenAmbiguity20.types | 10 + .../parserGreaterThanTokenAmbiguity3.symbols | 3 + .../parserGreaterThanTokenAmbiguity3.types | 8 + .../parserGreaterThanTokenAmbiguity4.symbols | 4 + .../parserGreaterThanTokenAmbiguity4.types | 10 + .../parserGreaterThanTokenAmbiguity7.symbols | 3 + .../parserGreaterThanTokenAmbiguity7.types | 8 + .../parserGreaterThanTokenAmbiguity8.symbols | 3 + .../parserGreaterThanTokenAmbiguity8.types | 8 + .../parserGreaterThanTokenAmbiguity9.symbols | 4 + .../parserGreaterThanTokenAmbiguity9.types | 10 + .../reference/parserIfStatement1.d.symbols | 4 + .../reference/parserIfStatement1.d.types | 4 + .../reference/parserIfStatement2.symbols | 4 + .../reference/parserIfStatement2.types | 4 + .../parserImportDeclaration1.symbols | 4 + .../reference/parserImportDeclaration1.types | 6 + .../reference/parserInExpression1.symbols | 3 + .../reference/parserInExpression1.types | 11 + .../parserIndexMemberDeclaration10.symbols | 7 + .../parserIndexMemberDeclaration10.types | 7 + .../parserIndexMemberDeclaration5.symbols | 8 + .../parserIndexMemberDeclaration5.types | 8 + .../parserIndexMemberDeclaration6.symbols | 7 + .../parserIndexMemberDeclaration6.types | 7 + .../parserIndexMemberDeclaration7.symbols | 7 + .../parserIndexMemberDeclaration7.types | 7 + .../parserIndexMemberDeclaration8.symbols | 7 + .../parserIndexMemberDeclaration8.types | 7 + .../parserIndexMemberDeclaration9.symbols | 7 + .../parserIndexMemberDeclaration9.types | 7 + .../reference/parserIndexSignature1.symbols | 7 + .../reference/parserIndexSignature1.types | 7 + .../reference/parserIndexSignature10.symbols | 8 + .../reference/parserIndexSignature10.types | 8 + .../reference/parserIndexSignature11.symbols | 12 + .../reference/parserIndexSignature11.types | 14 + .../reference/parserIndexSignature2.symbols | 7 + .../reference/parserIndexSignature2.types | 7 + .../reference/parserIndexSignature3.symbols | 7 + .../reference/parserIndexSignature3.types | 7 + .../reference/parserIndexSignature4.symbols | 6 + .../reference/parserIndexSignature4.types | 9 + .../reference/parserIndexSignature5.symbols | 6 + .../reference/parserIndexSignature5.types | 7 + .../reference/parserIndexSignature6.symbols | 7 + .../reference/parserIndexSignature6.types | 7 + .../reference/parserIndexSignature7.symbols | 7 + .../reference/parserIndexSignature7.types | 7 + .../reference/parserIndexSignature8.symbols | 10 + .../reference/parserIndexSignature8.types | 10 + .../reference/parserIndexSignature9.symbols | 6 + .../reference/parserIndexSignature9.types | 6 + .../parserInterfaceDeclaration1.symbols | 4 + .../parserInterfaceDeclaration1.types | 6 + .../parserInterfaceDeclaration2.symbols | 4 + .../parserInterfaceDeclaration2.types | 5 + .../parserInterfaceDeclaration3.symbols | 4 + .../parserInterfaceDeclaration3.types | 4 + .../parserInterfaceDeclaration4.symbols | 4 + .../parserInterfaceDeclaration4.types | 4 + .../parserInterfaceDeclaration6.symbols | 4 + .../parserInterfaceDeclaration6.types | 4 + .../parserInterfaceDeclaration8.symbols | 4 + .../parserInterfaceDeclaration8.types | 4 + ...idIdentifiersInVariableStatements1.symbols | 9 + ...alidIdentifiersInVariableStatements1.types | 9 + ...cessOffOfObjectCreationExpression1.symbols | 3 + ...AccessOffOfObjectCreationExpression1.types | 8 + .../parserKeywordsAsIdentifierName2.symbols | 4 + .../parserKeywordsAsIdentifierName2.types | 7 + .../parserLabeledStatement1.d.symbols | 4 + .../reference/parserLabeledStatement1.d.types | 8 + ...emberAccessAfterPostfixExpression1.symbols | 3 + ...rMemberAccessAfterPostfixExpression1.types | 7 + .../parserMemberAccessExpression1.symbols | 7 + .../parserMemberAccessExpression1.types | 28 + ...arserMemberAccessOffOfGenericType1.symbols | 4 + .../parserMemberAccessOffOfGenericType1.types | 8 + .../reference/parserMemberAccessor1.symbols | 11 + .../reference/parserMemberAccessor1.types | 11 + .../parserMemberAccessorDeclaration1.symbols | 7 + .../parserMemberAccessorDeclaration1.types | 7 + .../parserMemberAccessorDeclaration10.symbols | 7 + .../parserMemberAccessorDeclaration10.types | 7 + .../parserMemberAccessorDeclaration11.symbols | 7 + .../parserMemberAccessorDeclaration11.types | 7 + .../parserMemberAccessorDeclaration12.symbols | 8 + .../parserMemberAccessorDeclaration12.types | 8 + .../parserMemberAccessorDeclaration13.symbols | 7 + .../parserMemberAccessorDeclaration13.types | 7 + .../parserMemberAccessorDeclaration14.symbols | 9 + .../parserMemberAccessorDeclaration14.types | 9 + .../parserMemberAccessorDeclaration15.symbols | 8 + .../parserMemberAccessorDeclaration15.types | 8 + .../parserMemberAccessorDeclaration16.symbols | 8 + .../parserMemberAccessorDeclaration16.types | 9 + .../parserMemberAccessorDeclaration17.symbols | 8 + .../parserMemberAccessorDeclaration17.types | 8 + .../parserMemberAccessorDeclaration18.symbols | 8 + .../parserMemberAccessorDeclaration18.types | 8 + .../parserMemberAccessorDeclaration2.symbols | 6 + .../parserMemberAccessorDeclaration2.types | 6 + .../parserMemberAccessorDeclaration3.symbols | 6 + .../parserMemberAccessorDeclaration3.types | 6 + .../parserMemberAccessorDeclaration7.symbols | 7 + .../parserMemberAccessorDeclaration7.types | 7 + .../parserMemberAccessorDeclaration8.symbols | 7 + .../parserMemberAccessorDeclaration8.types | 7 + .../parserMemberAccessorDeclaration9.symbols | 7 + .../parserMemberAccessorDeclaration9.types | 7 + .../parserMemberFunctionDeclaration1.symbols | 7 + .../parserMemberFunctionDeclaration1.types | 7 + .../parserMemberFunctionDeclaration2.symbols | 7 + .../parserMemberFunctionDeclaration2.types | 7 + .../parserMemberFunctionDeclaration3.symbols | 7 + .../parserMemberFunctionDeclaration3.types | 7 + .../parserMemberFunctionDeclaration4.symbols | 7 + .../parserMemberFunctionDeclaration4.types | 7 + .../parserMemberFunctionDeclaration5.symbols | 7 + .../parserMemberFunctionDeclaration5.types | 7 + ...berFunctionDeclarationAmbiguities1.symbols | 28 + ...emberFunctionDeclarationAmbiguities1.types | 28 + .../parserMemberVariableDeclaration1.symbols | 7 + .../parserMemberVariableDeclaration1.types | 7 + .../parserMemberVariableDeclaration2.symbols | 7 + .../parserMemberVariableDeclaration2.types | 7 + .../parserMemberVariableDeclaration3.symbols | 7 + .../parserMemberVariableDeclaration3.types | 7 + .../parserMemberVariableDeclaration4.symbols | 7 + .../parserMemberVariableDeclaration4.types | 7 + .../parserMemberVariableDeclaration5.symbols | 7 + .../parserMemberVariableDeclaration5.types | 7 + .../parserMissingLambdaOpenBrace1.symbols | 28 + .../parserMissingLambdaOpenBrace1.types | 45 + .../reference/parserMissingToken1.symbols | 3 + .../reference/parserMissingToken1.types | 6 + .../reference/parserMissingToken2.symbols | 3 + .../reference/parserMissingToken2.types | 4 + ...parserModifierOnPropertySignature1.symbols | 8 + .../parserModifierOnPropertySignature1.types | 8 + .../parserModifierOnStatementInBlock1.symbols | 8 + .../parserModifierOnStatementInBlock1.types | 9 + .../parserModifierOnStatementInBlock2.symbols | 6 + .../parserModifierOnStatementInBlock2.types | 7 + .../parserModifierOnStatementInBlock3.symbols | 9 + .../parserModifierOnStatementInBlock3.types | 9 + .../parserModifierOnStatementInBlock4.symbols | 7 + .../parserModifierOnStatementInBlock4.types | 7 + .../parserModuleDeclaration1.d.symbols | 4 + .../parserModuleDeclaration1.d.types | 4 + .../parserModuleDeclaration1.symbols | 4 + .../reference/parserModuleDeclaration1.types | 4 + .../parserModuleDeclaration10.symbols | 7 + .../reference/parserModuleDeclaration10.types | 7 + .../parserModuleDeclaration2.d.symbols | 4 + .../parserModuleDeclaration2.d.types | 4 + .../parserModuleDeclaration3.symbols | 8 + .../reference/parserModuleDeclaration3.types | 8 + .../parserModuleDeclaration4.d.symbols | 8 + .../parserModuleDeclaration4.d.types | 8 + .../parserModuleDeclaration5.symbols | 12 + .../reference/parserModuleDeclaration5.types | 12 + ...oASIOnCallAfterFunctionExpression1.symbols | 6 + ...rNoASIOnCallAfterFunctionExpression1.types | 12 + .../reference/parserNotHexLiteral1.symbols | 18 + .../reference/parserNotHexLiteral1.types | 29 + .../reference/parserNotRegex1.symbols | 6 + .../baselines/reference/parserNotRegex1.types | 15 + .../reference/parserObjectCreation1.symbols | 5 + .../reference/parserObjectCreation1.types | 7 + .../reference/parserObjectCreation2.symbols | 3 + .../reference/parserObjectCreation2.types | 6 + .../parserObjectCreationArrayLiteral1.symbols | 3 + .../parserObjectCreationArrayLiteral1.types | 6 + .../parserObjectCreationArrayLiteral2.symbols | 3 + .../parserObjectCreationArrayLiteral2.types | 7 + .../parserObjectCreationArrayLiteral3.symbols | 3 + .../parserObjectCreationArrayLiteral3.types | 6 + .../parserObjectCreationArrayLiteral4.symbols | 3 + .../parserObjectCreationArrayLiteral4.types | 7 + .../reference/parserObjectType5.symbols | 11 + .../reference/parserObjectType5.types | 12 + .../reference/parserObjectType6.symbols | 9 + .../reference/parserObjectType6.types | 10 + .../parserOverloadOnConstants1.symbols | 20 + .../parserOverloadOnConstants1.types | 24 + .../reference/parserParameterList1.symbols | 9 + .../reference/parserParameterList1.types | 9 + .../reference/parserParameterList10.symbols | 8 + .../reference/parserParameterList10.types | 9 + .../reference/parserParameterList11.symbols | 4 + .../reference/parserParameterList11.types | 6 + .../reference/parserParameterList13.symbols | 7 + .../reference/parserParameterList13.types | 7 + .../reference/parserParameterList14.symbols | 8 + .../reference/parserParameterList14.types | 9 + .../reference/parserParameterList15.symbols | 10 + .../reference/parserParameterList15.types | 11 + .../reference/parserParameterList16.symbols | 13 + .../reference/parserParameterList16.types | 14 + .../reference/parserParameterList17.symbols | 11 + .../reference/parserParameterList17.types | 12 + .../reference/parserParameterList2.symbols | 8 + .../reference/parserParameterList2.types | 9 + .../reference/parserParameterList3.symbols | 9 + .../reference/parserParameterList3.types | 9 + .../reference/parserParameterList4.symbols | 5 + .../reference/parserParameterList4.types | 5 + .../reference/parserParameterList5.symbols | 5 + .../reference/parserParameterList5.types | 6 + .../reference/parserParameterList6.symbols | 9 + .../reference/parserParameterList6.types | 9 + .../reference/parserParameterList7.symbols | 13 + .../reference/parserParameterList7.types | 13 + .../reference/parserParameterList8.symbols | 13 + .../reference/parserParameterList8.types | 13 + .../reference/parserParameterList9.symbols | 8 + .../reference/parserParameterList9.types | 8 + .../parserPostfixPostfixExpression1.symbols | 3 + .../parserPostfixPostfixExpression1.types | 7 + .../parserPostfixUnaryExpression1.symbols | 3 + .../parserPostfixUnaryExpression1.types | 7 + .../reference/parserPublicBreak1.symbols | 4 + .../reference/parserPublicBreak1.types | 4 + .../reference/parserRealSource1.symbols | 443 + .../reference/parserRealSource1.types | 542 + .../reference/parserRealSource10.symbols | 2640 + .../reference/parserRealSource10.types | 3977 + .../reference/parserRealSource11.symbols | 7190 ++ .../reference/parserRealSource11.types | 11518 +++ .../reference/parserRealSource12.symbols | 2413 + .../reference/parserRealSource12.types | 3688 + .../reference/parserRealSource13.symbols | 638 + .../reference/parserRealSource13.types | 787 + .../reference/parserRealSource14.symbols | 2537 + .../reference/parserRealSource14.types | 4394 + .../reference/parserRealSource2.symbols | 734 + .../reference/parserRealSource2.types | 1237 + .../reference/parserRealSource3.symbols | 343 + .../reference/parserRealSource3.types | 343 + .../reference/parserRealSource4.symbols | 1010 + .../reference/parserRealSource4.types | 1188 + .../reference/parserRealSource5.symbols | 193 + .../reference/parserRealSource5.types | 242 + .../reference/parserRealSource6.symbols | 621 + .../reference/parserRealSource6.types | 956 + .../reference/parserRealSource7.symbols | 2183 + .../reference/parserRealSource7.types | 4728 ++ .../reference/parserRealSource8.symbols | 1328 + .../reference/parserRealSource8.types | 2451 + .../reference/parserRealSource9.symbols | 658 + .../reference/parserRealSource9.types | 1164 + .../parserRegularExpression1.symbols | 3 + .../reference/parserRegularExpression1.types | 4 + .../parserRegularExpression2.symbols | 3 + .../reference/parserRegularExpression2.types | 10 + .../parserRegularExpression3.symbols | 3 + .../reference/parserRegularExpression3.types | 7 + .../parserRegularExpression4.symbols | 12 + .../reference/parserRegularExpression4.types | 92 + .../parserRegularExpression5.symbols | 5 + .../reference/parserRegularExpression5.types | 11 + ...rRegularExpressionDivideAmbiguity1.symbols | 4 + ...serRegularExpressionDivideAmbiguity1.types | 13 + ...rRegularExpressionDivideAmbiguity2.symbols | 3 + ...serRegularExpressionDivideAmbiguity2.types | 12 + ...rRegularExpressionDivideAmbiguity3.symbols | 3 + ...serRegularExpressionDivideAmbiguity3.types | 8 + ...rRegularExpressionDivideAmbiguity4.symbols | 3 + ...serRegularExpressionDivideAmbiguity4.types | 6 + ...rRegularExpressionDivideAmbiguity5.symbols | 9 + ...serRegularExpressionDivideAmbiguity5.types | 22 + ...rRegularExpressionDivideAmbiguity7.symbols | 5 + ...serRegularExpressionDivideAmbiguity7.types | 9 + .../parserReturnStatement1.d.symbols | 3 + .../reference/parserReturnStatement1.d.types | 3 + .../reference/parserReturnStatement1.symbols | 3 + .../reference/parserReturnStatement1.types | 3 + .../reference/parserReturnStatement2.symbols | 5 + .../reference/parserReturnStatement2.types | 5 + .../reference/parserReturnStatement4.symbols | 5 + .../reference/parserReturnStatement4.types | 6 + .../reference/parserS12.11_A3_T4.symbols | 42 + .../reference/parserS12.11_A3_T4.types | 51 + .../reference/parserS7.2_A1.5_T2.symbols | 35 + .../reference/parserS7.2_A1.5_T2.types | 52 + .../reference/parserS7.3_A1.1_T2.symbols | 26 + .../reference/parserS7.3_A1.1_T2.types | 35 + .../reference/parserS7.6_A4.2_T1.symbols | 278 + .../reference/parserS7.6_A4.2_T1.types | 476 + .../reference/parserS7.9_A5.7_T1.symbols | 29 + .../reference/parserS7.9_A5.7_T1.types | 36 + ...rserSetAccessorWithTypeAnnotation1.symbols | 9 + ...parserSetAccessorWithTypeAnnotation1.types | 9 + ...rserSetAccessorWithTypeParameters1.symbols | 9 + ...parserSetAccessorWithTypeParameters1.types | 9 + ...parserShorthandPropertyAssignment1.symbols | 16 + .../parserShorthandPropertyAssignment1.types | 18 + ...parserShorthandPropertyAssignment2.symbols | 5 + .../parserShorthandPropertyAssignment2.types | 7 + ...parserShorthandPropertyAssignment3.symbols | 4 + .../parserShorthandPropertyAssignment3.types | 6 + ...parserShorthandPropertyAssignment4.symbols | 4 + .../parserShorthandPropertyAssignment4.types | 6 + ...parserShorthandPropertyAssignment5.symbols | 8 + .../parserShorthandPropertyAssignment5.types | 10 + .../reference/parserSkippedTokens1.symbols | 3 + .../reference/parserSkippedTokens1.types | 3 + .../reference/parserSkippedTokens10.symbols | 6 + .../reference/parserSkippedTokens10.types | 6 + .../reference/parserSkippedTokens11.symbols | 3 + .../reference/parserSkippedTokens11.types | 3 + .../reference/parserSkippedTokens12.symbols | 3 + .../reference/parserSkippedTokens12.types | 3 + .../reference/parserSkippedTokens13.symbols | 3 + .../reference/parserSkippedTokens13.types | 4 + .../reference/parserSkippedTokens14.symbols | 7 + .../reference/parserSkippedTokens14.types | 7 + .../reference/parserSkippedTokens15.symbols | 6 + .../reference/parserSkippedTokens15.types | 6 + .../reference/parserSkippedTokens16.symbols | 18 + .../reference/parserSkippedTokens16.types | 28 + .../reference/parserSkippedTokens17.symbols | 3 + .../reference/parserSkippedTokens17.types | 6 + .../reference/parserSkippedTokens18.symbols | 3 + .../reference/parserSkippedTokens18.types | 6 + .../reference/parserSkippedTokens19.symbols | 4 + .../reference/parserSkippedTokens19.types | 4 + .../reference/parserSkippedTokens2.symbols | 3 + .../reference/parserSkippedTokens2.types | 3 + .../reference/parserSkippedTokens20.symbols | 4 + .../reference/parserSkippedTokens20.types | 6 + .../reference/parserSkippedTokens3.symbols | 3 + .../reference/parserSkippedTokens3.types | 3 + .../reference/parserSkippedTokens4.symbols | 3 + .../reference/parserSkippedTokens4.types | 4 + .../reference/parserSkippedTokens5.symbols | 3 + .../reference/parserSkippedTokens5.types | 3 + .../reference/parserSkippedTokens6.symbols | 3 + .../reference/parserSkippedTokens6.types | 3 + .../reference/parserSkippedTokens7.symbols | 3 + .../reference/parserSkippedTokens7.types | 3 + .../reference/parserSkippedTokens8.symbols | 4 + .../reference/parserSkippedTokens8.types | 4 + .../reference/parserSkippedTokens9.symbols | 4 + .../reference/parserSkippedTokens9.types | 4 + ...ntIsNotAMemberVariableDeclaration1.symbols | 15 + ...mentIsNotAMemberVariableDeclaration1.types | 20 + .../reference/parserStrictMode1.symbols | 6 + .../reference/parserStrictMode1.types | 17 + .../reference/parserStrictMode10.symbols | 6 + .../reference/parserStrictMode10.types | 8 + .../reference/parserStrictMode11.symbols | 8 + .../reference/parserStrictMode11.types | 11 + .../reference/parserStrictMode12.symbols | 7 + .../reference/parserStrictMode12.types | 10 + .../reference/parserStrictMode13.symbols | 7 + .../reference/parserStrictMode13.types | 9 + .../reference/parserStrictMode14.symbols | 5 + .../reference/parserStrictMode14.types | 7 + .../parserStrictMode15-negative.symbols | 4 + .../parserStrictMode15-negative.types | 10 + .../reference/parserStrictMode15.symbols | 4 + .../reference/parserStrictMode15.types | 8 + .../reference/parserStrictMode2.symbols | 7 + .../reference/parserStrictMode2.types | 20 + .../parserStrictMode3-negative.symbols | 4 + .../parserStrictMode3-negative.types | 6 + .../reference/parserStrictMode3.symbols | 5 + .../reference/parserStrictMode3.types | 9 + .../reference/parserStrictMode4.symbols | 4 + .../reference/parserStrictMode4.types | 9 + .../reference/parserStrictMode5.symbols | 5 + .../reference/parserStrictMode5.types | 9 + .../parserStrictMode6-negative.symbols | 4 + .../parserStrictMode6-negative.types | 5 + .../reference/parserStrictMode6.symbols | 5 + .../reference/parserStrictMode6.types | 8 + .../reference/parserStrictMode7.symbols | 5 + .../reference/parserStrictMode7.types | 8 + .../reference/parserStrictMode8.symbols | 5 + .../reference/parserStrictMode8.types | 7 + .../reference/parserStrictMode9.symbols | 7 + .../reference/parserStrictMode9.types | 10 + .../reference/parserSuperExpression1.symbols | 25 + .../reference/parserSuperExpression1.types | 33 + .../reference/parserSuperExpression2.symbols | 10 + .../reference/parserSuperExpression2.types | 16 + .../reference/parserSuperExpression3.symbols | 11 + .../reference/parserSuperExpression3.types | 16 + .../reference/parserSuperExpression4.symbols | 25 + .../reference/parserSuperExpression4.types | 35 + .../parserSwitchStatement1.d.symbols | 4 + .../reference/parserSwitchStatement1.d.types | 4 + .../reference/parserSymbolIndexer1.symbols | 7 + .../reference/parserSymbolIndexer1.types | 7 + .../reference/parserSymbolIndexer2.symbols | 7 + .../reference/parserSymbolIndexer2.types | 7 + .../reference/parserSymbolIndexer3.symbols | 7 + .../reference/parserSymbolIndexer3.types | 7 + .../reference/parserSymbolIndexer4.symbols | 7 + .../reference/parserSymbolIndexer4.types | 7 + .../reference/parserSymbolIndexer5.symbols | 6 + .../reference/parserSymbolIndexer5.types | 11 + .../parserTernaryAndCommaOperators1.symbols | 4 + .../parserTernaryAndCommaOperators1.types | 13 + .../reference/parserThrowStatement1.d.symbols | 3 + .../reference/parserThrowStatement1.d.types | 4 + .../reference/parserTryStatement1.d.symbols | 6 + .../reference/parserTryStatement1.d.types | 6 + ...sertionInObjectCreationExpression1.symbols | 3 + ...AssertionInObjectCreationExpression1.types | 10 + .../reference/parserTypeQuery1.symbols | 4 + .../reference/parserTypeQuery1.types | 5 + .../reference/parserTypeQuery2.symbols | 4 + .../reference/parserTypeQuery2.types | 5 + .../reference/parserTypeQuery3.symbols | 4 + .../reference/parserTypeQuery3.types | 7 + .../reference/parserTypeQuery4.symbols | 4 + .../reference/parserTypeQuery4.types | 7 + .../reference/parserTypeQuery5.symbols | 4 + .../reference/parserTypeQuery5.types | 7 + .../reference/parserTypeQuery6.symbols | 4 + .../reference/parserTypeQuery6.types | 7 + .../reference/parserTypeQuery7.symbols | 4 + .../reference/parserTypeQuery7.types | 5 + .../reference/parserTypeQuery8.symbols | 4 + .../reference/parserTypeQuery8.types | 8 + .../reference/parserTypeQuery9.symbols | 4 + .../reference/parserTypeQuery9.types | 5 + .../reference/parserUnaryExpression1.symbols | 3 + .../reference/parserUnaryExpression1.types | 5 + .../reference/parserUnaryExpression2.symbols | 4 + .../reference/parserUnaryExpression2.types | 6 + .../reference/parserUnaryExpression3.symbols | 3 + .../reference/parserUnaryExpression3.types | 6 + .../reference/parserUnaryExpression4.symbols | 3 + .../reference/parserUnaryExpression4.types | 5 + .../reference/parserUnaryExpression5.symbols | 3 + .../reference/parserUnaryExpression5.types | 9 + .../reference/parserUnaryExpression7.symbols | 3 + .../reference/parserUnaryExpression7.types | 6 + ...erUnfinishedTypeNameBeforeKeyword1.symbols | 8 + ...rserUnfinishedTypeNameBeforeKeyword1.types | 10 + .../reference/parserUnicode1.symbols | 19 + .../baselines/reference/parserUnicode1.types | 32 + .../parserUnterminatedGeneric1.symbols | 8 + .../parserUnterminatedGeneric1.types | 10 + .../parserUnterminatedGeneric2.symbols | 19 + .../parserUnterminatedGeneric2.types | 32 + ...parserUsingConstructorAsIdentifier.symbols | 127 + .../parserUsingConstructorAsIdentifier.types | 186 + .../parserVariableDeclaration1.symbols | 13 + .../parserVariableDeclaration1.types | 17 + .../parserVariableDeclaration10.symbols | 4 + .../parserVariableDeclaration10.types | 4 + .../parserVariableDeclaration2.symbols | 12 + .../parserVariableDeclaration2.types | 24 + .../parserVariableDeclaration3.symbols | 17 + .../parserVariableDeclaration3.types | 36 + .../parserVariableDeclaration4.symbols | 7 + .../parserVariableDeclaration4.types | 7 + .../parserVariableDeclaration5.symbols | 4 + .../parserVariableDeclaration5.types | 4 + .../parserVariableDeclaration6.symbols | 3 + .../parserVariableDeclaration6.types | 3 + .../parserVariableDeclaration8.symbols | 3 + .../parserVariableDeclaration8.types | 3 + .../parserVariableStatement1.d.symbols | 4 + .../parserVariableStatement1.d.types | 5 + .../parserVariableStatement2.d.symbols | 4 + .../parserVariableStatement2.d.types | 4 + .../reference/parserWhileStatement1.d.symbols | 4 + .../reference/parserWhileStatement1.d.types | 4 + .../reference/parserWithStatement1.d.symbols | 4 + .../reference/parserWithStatement1.d.types | 4 + .../reference/parserWithStatement2.symbols | 4 + .../reference/parserWithStatement2.types | 5 + .../reference/parserX_ArrowFunction1.symbols | 6 + .../reference/parserX_ArrowFunction1.types | 8 + .../reference/parserX_ArrowFunction3.symbols | 6 + .../reference/parserX_ArrowFunction3.types | 8 + .../parserX_TypeArgumentList1.symbols | 3 + .../reference/parserX_TypeArgumentList1.types | 18 + ...breakInIterationOrSwitchStatement4.symbols | 6 + ...r_breakInIterationOrSwitchStatement4.types | 7 + ...akNotInIterationOrSwitchStatement1.symbols | 3 + ...reakNotInIterationOrSwitchStatement1.types | 3 + ...akNotInIterationOrSwitchStatement2.symbols | 8 + ...reakNotInIterationOrSwitchStatement2.types | 10 + .../reference/parser_breakTarget5.symbols | 11 + .../reference/parser_breakTarget5.types | 18 + .../reference/parser_breakTarget6.symbols | 5 + .../reference/parser_breakTarget6.types | 7 + ...rser_continueInIterationStatement4.symbols | 6 + ...parser_continueInIterationStatement4.types | 7 + ...r_continueNotInIterationStatement1.symbols | 3 + ...ser_continueNotInIterationStatement1.types | 3 + ...r_continueNotInIterationStatement2.symbols | 8 + ...ser_continueNotInIterationStatement2.types | 10 + ...r_continueNotInIterationStatement3.symbols | 6 + ...ser_continueNotInIterationStatement3.types | 7 + ...r_continueNotInIterationStatement4.symbols | 10 + ...ser_continueNotInIterationStatement4.types | 16 + .../reference/parser_continueTarget1.symbols | 4 + .../reference/parser_continueTarget1.types | 7 + .../reference/parser_continueTarget5.symbols | 11 + .../reference/parser_continueTarget5.types | 18 + .../reference/parser_continueTarget6.symbols | 5 + .../reference/parser_continueTarget6.types | 7 + .../reference/parser_duplicateLabel1.symbols | 6 + .../reference/parser_duplicateLabel1.types | 10 + .../reference/parser_duplicateLabel2.symbols | 8 + .../reference/parser_duplicateLabel2.types | 14 + .../baselines/reference/parserharness.symbols | 6184 ++ tests/baselines/reference/parserharness.types | 8666 ++ .../reference/parserindenter.symbols | 1805 + .../baselines/reference/parserindenter.types | 3119 + .../parservoidInQualifiedName1.symbols | 5 + .../parservoidInQualifiedName1.types | 5 + .../parservoidInQualifiedName2.symbols | 4 + .../parservoidInQualifiedName2.types | 8 + ...llyAnnotatedFunctionInferenceError.symbols | 49 + ...iallyAnnotatedFunctionInferenceError.types | 55 + ...pingBasedModuleResolution1_classic.symbols | 4 + ...appingBasedModuleResolution1_classic.types | 5 + ...MappingBasedModuleResolution1_node.symbols | 4 + ...thMappingBasedModuleResolution1_node.types | 5 + ...pingBasedModuleResolution2_classic.symbols | 4 + ...appingBasedModuleResolution2_classic.types | 5 + ...MappingBasedModuleResolution2_node.symbols | 4 + ...thMappingBasedModuleResolution2_node.types | 5 + ...olution_withExtension_failedLookup.symbols | 4 + ...esolution_withExtension_failedLookup.types | 4 + .../reference/pathsValidation1.symbols | 4 + .../reference/pathsValidation1.types | 5 + .../reference/pathsValidation2.symbols | 4 + .../reference/pathsValidation2.types | 5 + .../reference/pathsValidation3.symbols | 4 + .../reference/pathsValidation3.types | 5 + .../plusOperatorInvalidOperations.symbols | 14 + .../plusOperatorInvalidOperations.types | 18 + .../plusOperatorWithAnyOtherType.symbols | 170 + .../plusOperatorWithAnyOtherType.types | 221 + .../plusOperatorWithNumberType.types | 4 +- .../prettyContextNotDebugAssertion.symbols | 4 + .../prettyContextNotDebugAssertion.types | 4 + .../reference/primaryExpressionMods.symbols | 39 + .../reference/primaryExpressionMods.types | 45 + .../reference/primitiveConstraints1.symbols | 27 + .../reference/primitiveConstraints1.types | 33 + .../reference/primitiveConstraints2.symbols | 33 + .../reference/primitiveConstraints2.types | 41 + .../reference/primitiveMembers.symbols | 82 + .../reference/primitiveMembers.types | 100 + .../primitiveTypeAsClassName.symbols | 4 + .../reference/primitiveTypeAsClassName.types | 4 + .../primitiveTypeAsInterfaceName.symbols | 4 + .../primitiveTypeAsInterfaceName.types | 4 + ...rimitiveTypeAsInterfaceNameGeneric.symbols | 5 + .../primitiveTypeAsInterfaceNameGeneric.types | 5 + .../reference/primitiveTypeAssignment.symbols | 10 + .../reference/primitiveTypeAssignment.types | 13 + .../reference/privacyAccessorDeclFile.symbols | 2216 + .../reference/privacyAccessorDeclFile.types | 2424 + .../privacyCannotNameAccessorDeclFile.symbols | 318 + .../privacyCannotNameAccessorDeclFile.types | 350 + .../privacyCannotNameVarTypeDeclFile.symbols | 313 + .../privacyCannotNameVarTypeDeclFile.types | 353 + .../privacyCheckTypeOfFunction.symbols | 12 + .../privacyCheckTypeOfFunction.types | 12 + ...acyCheckTypeOfInvisibleModuleError.symbols | 17 + ...ivacyCheckTypeOfInvisibleModuleError.types | 17 + ...yCheckTypeOfInvisibleModuleNoError.symbols | 16 + ...acyCheckTypeOfInvisibleModuleNoError.types | 16 + .../privacyClassExtendsClauseDeclFile.symbols | 176 + .../privacyClassExtendsClauseDeclFile.types | 176 + ...ivacyClassImplementsClauseDeclFile.symbols | 168 + ...privacyClassImplementsClauseDeclFile.types | 168 + ...ionCannotNameParameterTypeDeclFile.symbols | 481 + ...ctionCannotNameParameterTypeDeclFile.types | 545 + ...nctionCannotNameReturnTypeDeclFile.symbols | 384 + ...FunctionCannotNameReturnTypeDeclFile.types | 424 + .../privacyFunctionParameterDeclFile.symbols | 1967 + .../privacyFunctionParameterDeclFile.types | 1967 + .../privacyFunctionReturnTypeDeclFile.symbols | 2640 + .../privacyFunctionReturnTypeDeclFile.types | 2910 + .../reference/privacyGloImport.symbols | 351 + .../reference/privacyGloImport.types | 363 + .../privacyGloImportParseErrors.symbols | 427 + .../privacyGloImportParseErrors.types | 479 + .../baselines/reference/privacyImport.symbols | 709 + tests/baselines/reference/privacyImport.types | 741 + .../privacyImportParseErrors.symbols | 1044 + .../reference/privacyImportParseErrors.types | 1200 + ...vacyInterfaceExtendsClauseDeclFile.symbols | 168 + ...rivacyInterfaceExtendsClauseDeclFile.types | 168 + ...lInternalReferenceImportWithExport.symbols | 510 + ...calInternalReferenceImportWithExport.types | 538 + ...ternalReferenceImportWithoutExport.symbols | 510 + ...InternalReferenceImportWithoutExport.types | 538 + ...ientExternalModuleImportWithExport.symbols | 105 + ...mbientExternalModuleImportWithExport.types | 113 + ...tExternalModuleImportWithoutExport.symbols | 104 + ...entExternalModuleImportWithoutExport.types | 112 + ...lInternalReferenceImportWithExport.symbols | 297 + ...velInternalReferenceImportWithExport.types | 313 + ...ternalReferenceImportWithoutExport.symbols | 297 + ...InternalReferenceImportWithoutExport.types | 313 + ...acyTypeParameterOfFunctionDeclFile.symbols | 1095 + ...ivacyTypeParameterOfFunctionDeclFile.types | 1095 + ...ivacyTypeParametersOfClassDeclFile.symbols | 383 + ...privacyTypeParametersOfClassDeclFile.types | 383 + ...yTypeParametersOfInterfaceDeclFile.symbols | 631 + ...acyTypeParametersOfInterfaceDeclFile.types | 631 + .../reference/privacyVarDeclFile.symbols | 1124 + .../reference/privacyVarDeclFile.types | 1124 + .../privateAccessInSubclass1.symbols | 21 + .../reference/privateAccessInSubclass1.types | 21 + ...ClassPropertyAccessibleWithinClass.symbols | 126 + ...teClassPropertyAccessibleWithinClass.types | 141 + .../reference/privateIndexer.symbols | 25 + .../baselines/reference/privateIndexer.types | 25 + .../reference/privateIndexer2.symbols | 17 + .../baselines/reference/privateIndexer2.types | 20 + ...privateInstanceMemberAccessibility.symbols | 33 + .../privateInstanceMemberAccessibility.types | 36 + .../privateInterfaceProperties.symbols | 18 + .../privateInterfaceProperties.types | 18 + ...mbersAreNotAccessibleDestructuring.symbols | 72 + ...MembersAreNotAccessibleDestructuring.types | 74 + .../privateStaticMemberAccessibility.symbols | 24 + .../privateStaticMemberAccessibility.types | 25 + ...rivateStaticNotAccessibleInClodule.symbols | 22 + .../privateStaticNotAccessibleInClodule.types | 22 + ...ivateStaticNotAccessibleInClodule2.symbols | 30 + ...privateStaticNotAccessibleInClodule2.types | 30 + .../reference/privateVisibility.symbols | 74 + .../reference/privateVisibility.types | 84 + .../reference/promiseChaining1.symbols | 48 + .../reference/promiseChaining1.types | 61 + .../reference/promiseChaining2.symbols | 48 + .../reference/promiseChaining2.types | 61 + .../promiseEmptyTupleNoException.symbols | 12 + .../promiseEmptyTupleNoException.types | 13 + .../reference/promiseIdentity2.symbols | 50 + .../reference/promiseIdentity2.types | 50 + .../reference/promiseIdentityWithAny2.symbols | 88 + .../reference/promiseIdentityWithAny2.types | 88 + .../reference/promisePermutations.symbols | 1336 + .../reference/promisePermutations.types | 1445 + .../reference/promisePermutations2.symbols | 1289 + .../reference/promisePermutations2.types | 1398 + .../reference/promisePermutations3.symbols | 1289 + .../reference/promisePermutations3.types | 1398 + .../reference/promiseTypeInference.types | 4 +- .../reference/propertiesAndIndexers.symbols | 107 + .../reference/propertiesAndIndexers.types | 107 + .../reference/propertiesAndIndexers2.symbols | 31 + .../reference/propertiesAndIndexers2.types | 31 + ...opertiesAndIndexersForNumericNames.symbols | 46 + ...propertiesAndIndexersForNumericNames.types | 97 + .../reference/propertyAccess.symbols | 360 + .../baselines/reference/propertyAccess.types | 436 + .../reference/propertyAccess1.symbols | 13 + .../baselines/reference/propertyAccess1.types | 19 + .../reference/propertyAccess2.symbols | 7 + .../baselines/reference/propertyAccess2.types | 10 + .../reference/propertyAccess3.symbols | 7 + .../baselines/reference/propertyAccess3.types | 10 + .../reference/propertyAccess4.symbols | 3 + .../baselines/reference/propertyAccess4.types | 7 + .../reference/propertyAccess5.symbols | 4 + .../baselines/reference/propertyAccess5.types | 7 + ...ertyAccessOfReadonlyIndexSignature.symbols | 15 + ...opertyAccessOfReadonlyIndexSignature.types | 19 + ...essOnTypeParameterWithConstraints4.symbols | 102 + ...ccessOnTypeParameterWithConstraints4.types | 145 + ...essOnTypeParameterWithConstraints5.symbols | 139 + ...ccessOnTypeParameterWithConstraints5.types | 183 + ...propertyAccessStringIndexSignature.symbols | 34 + .../propertyAccessStringIndexSignature.types | 46 + ...sStringIndexSignatureNoImplicitAny.symbols | 34 + ...essStringIndexSignatureNoImplicitAny.types | 46 + .../reference/propertyAccessibility1.symbols | 16 + .../reference/propertyAccessibility1.types | 18 + .../reference/propertyAccessibility2.symbols | 13 + .../reference/propertyAccessibility2.types | 14 + .../propertyAndAccessorWithSameName.symbols | 40 + .../propertyAndAccessorWithSameName.types | 42 + .../propertyAndFunctionWithSameName.symbols | 24 + .../propertyAndFunctionWithSameName.types | 25 + .../reference/propertyAssignment.symbols | 36 + .../reference/propertyAssignment.types | 40 + ...ropertyIdentityWithPrivacyMismatch.symbols | 56 + .../propertyIdentityWithPrivacyMismatch.types | 56 + .../reference/propertyOrdering.symbols | 44 + .../reference/propertyOrdering.types | 56 + .../reference/propertyOrdering2.symbols | 22 + .../reference/propertyOrdering2.types | 24 + .../propertyParameterWithQuestionMark.symbols | 26 + .../propertyParameterWithQuestionMark.types | 29 + .../reference/propertySignatures.symbols | 44 + .../reference/propertySignatures.types | 55 + .../reference/propertyWrappedInTry.symbols | 22 + .../reference/propertyWrappedInTry.types | 31 + ...ertyAccessibleWithinNestedSubclass.symbols | 141 + ...opertyAccessibleWithinNestedSubclass.types | 147 + ...rtyAccessibleWithinNestedSubclass1.symbols | 362 + ...pertyAccessibleWithinNestedSubclass1.types | 362 + ...sPropertyAccessibleWithinSubclass2.symbols | 322 + ...assPropertyAccessibleWithinSubclass2.types | 322 + ...sPropertyAccessibleWithinSubclass3.symbols | 35 + ...assPropertyAccessibleWithinSubclass3.types | 35 + ...otectedInstanceMemberAccessibility.symbols | 152 + ...protectedInstanceMemberAccessibility.types | 172 + .../reference/protectedMembers.symbols | 305 + .../reference/protectedMembers.types | 329 + ...ssPropertyAccessibleWithinSubclass.symbols | 143 + ...lassPropertyAccessibleWithinSubclass.types | 143 + ...sPropertyAccessibleWithinSubclass2.symbols | 57 + ...assPropertyAccessibleWithinSubclass2.types | 57 + ...tectedStaticNotAccessibleInClodule.symbols | 28 + ...rotectedStaticNotAccessibleInClodule.types | 28 + .../reference/protoAssignment.symbols | 25 + .../baselines/reference/protoAssignment.types | 33 + tests/baselines/reference/prototypes.symbols | 17 + tests/baselines/reference/prototypes.types | 20 + .../baselines/reference/publicIndexer.symbols | 25 + tests/baselines/reference/publicIndexer.types | 25 + ...ImplementedAsPrivateInDerivedClass.symbols | 15 + ...erImplementedAsPrivateInDerivedClass.types | 15 + .../reference/qualifiedModuleLocals.symbols | 18 + .../reference/qualifiedModuleLocals.types | 22 + ...ion-does-not-affect-class-heritage.symbols | 14 + ...ution-does-not-affect-class-heritage.types | 15 + tests/baselines/reference/qualify.symbols | 150 + tests/baselines/reference/qualify.types | 155 + .../reference/quotedAccessorName1.symbols | 6 + .../reference/quotedAccessorName1.types | 7 + .../reference/quotedAccessorName2.symbols | 6 + .../reference/quotedAccessorName2.types | 7 + .../quotedModuleNameMustBeAmbient.symbols | 5 + .../quotedModuleNameMustBeAmbient.types | 5 + .../raiseErrorOnParameterProperty.symbols | 13 + .../raiseErrorOnParameterProperty.types | 16 + .../reExportGlobalDeclaration1.symbols | 51 + .../reExportGlobalDeclaration1.types | 51 + .../reExportGlobalDeclaration2.symbols | 34 + .../reExportGlobalDeclaration2.types | 34 + .../reExportGlobalDeclaration3.symbols | 34 + .../reExportGlobalDeclaration3.types | 34 + .../reExportGlobalDeclaration4.symbols | 34 + .../reExportGlobalDeclaration4.types | 34 + .../reference/reExportUndefined1.symbols | 4 + .../reference/reExportUndefined1.types | 4 + .../reference/reachabilityChecks1.symbols | 122 + .../reference/reachabilityChecks1.types | 145 + .../reference/reachabilityChecks2.symbols | 20 + .../reference/reachabilityChecks2.types | 24 + .../reference/reachabilityChecks3.symbols | 22 + .../reference/reachabilityChecks3.types | 34 + .../reference/reachabilityChecks4.symbols | 22 + .../reference/reachabilityChecks4.types | 34 + .../reference/reachabilityChecks5.symbols | 207 + .../reference/reachabilityChecks5.types | 242 + .../reference/reachabilityChecks6.symbols | 207 + .../reference/reachabilityChecks6.types | 242 + .../reference/reachabilityChecks7.symbols | 52 + .../reference/reachabilityChecks7.types | 58 + .../reactNamespaceInvalidInput.symbols | 5 + .../reactNamespaceInvalidInput.types | 6 + .../reactNamespaceMissingDeclaration.symbols | 6 + .../reactNamespaceMissingDeclaration.types | 7 + .../readonlyConstructorAssignment.symbols | 87 + .../readonlyConstructorAssignment.types | 100 + .../reference/readonlyInAmbientClass.symbols | 11 + .../reference/readonlyInAmbientClass.types | 11 + .../readonlyInConstructorParameters.symbols | 30 + .../readonlyInConstructorParameters.types | 36 + .../readonlyInNonPropertyParameters.symbols | 20 + .../readonlyInNonPropertyParameters.types | 24 + .../reference/readonlyMembers.symbols | 211 + .../baselines/reference/readonlyMembers.types | 281 + .../reference/readonlyReadonly.symbols | 10 + .../reference/readonlyReadonly.types | 10 + .../reference/reassignStaticProp.symbols | 15 + .../reference/reassignStaticProp.types | 16 + .../reboundIdentifierOnImportAlias.symbols | 17 + .../reboundIdentifierOnImportAlias.types | 19 + .../reference/recursiveBaseCheck.symbols | 44 + .../reference/recursiveBaseCheck.types | 44 + .../reference/recursiveBaseCheck2.symbols | 45 + .../reference/recursiveBaseCheck2.types | 45 + .../reference/recursiveBaseCheck3.symbols | 16 + .../reference/recursiveBaseCheck3.types | 20 + .../reference/recursiveBaseCheck4.symbols | 9 + .../reference/recursiveBaseCheck4.types | 13 + .../reference/recursiveBaseCheck5.symbols | 22 + .../reference/recursiveBaseCheck5.types | 26 + .../reference/recursiveBaseCheck6.symbols | 11 + .../reference/recursiveBaseCheck6.types | 15 + .../recursiveBaseConstructorCreation3.symbols | 29 + .../recursiveBaseConstructorCreation3.types | 32 + .../recursiveClassReferenceTest.symbols | 224 + .../recursiveClassReferenceTest.types | 237 + ...xportAssignmentAndFindAliasedType1.symbols | 28 + ...eExportAssignmentAndFindAliasedType1.types | 28 + ...xportAssignmentAndFindAliasedType2.symbols | 35 + ...eExportAssignmentAndFindAliasedType2.types | 35 + ...xportAssignmentAndFindAliasedType3.symbols | 42 + ...eExportAssignmentAndFindAliasedType3.types | 42 + ...xportAssignmentAndFindAliasedType4.symbols | 25 + ...eExportAssignmentAndFindAliasedType4.types | 25 + ...xportAssignmentAndFindAliasedType5.symbols | 32 + ...eExportAssignmentAndFindAliasedType5.types | 32 + ...xportAssignmentAndFindAliasedType6.symbols | 39 + ...eExportAssignmentAndFindAliasedType6.types | 39 + .../reference/recursiveFunctionTypes.symbols | 125 + .../reference/recursiveFunctionTypes.types | 142 + .../reference/recursiveGetterAccess.symbols | 12 + .../reference/recursiveGetterAccess.types | 12 + .../reference/recursiveInferenceBug.symbols | 26 + .../reference/recursiveInferenceBug.types | 30 + .../reference/recursiveInheritance.symbols | 17 + .../reference/recursiveInheritance.types | 17 + .../reference/recursiveInheritance3.symbols | 22 + .../reference/recursiveInheritance3.types | 23 + .../recursiveInheritanceGeneric.symbols | 10 + .../recursiveInheritanceGeneric.types | 10 + .../recursiveIntersectionTypes.symbols | 78 + .../recursiveIntersectionTypes.types | 80 + .../reference/recursiveLetConst.symbols | 55 + .../reference/recursiveLetConst.types | 69 + .../reference/recursiveMappedTypes.symbols | 25 +- .../reference/recursiveMappedTypes.types | 19 +- .../recursiveNamedLambdaCall.symbols | 27 + .../reference/recursiveNamedLambdaCall.types | 49 + ...ecursiveSpecializationOfSignatures.symbols | 18 + .../recursiveSpecializationOfSignatures.types | 18 + .../recursiveTypeComparison2.symbols | 157 + .../reference/recursiveTypeComparison2.types | 159 + ...erConstraintReferenceLacksTypeArgs.symbols | 6 + ...eterConstraintReferenceLacksTypeArgs.types | 6 + .../reference/recursiveTypeRelations.symbols | 123 + .../reference/recursiveTypeRelations.types | 148 + .../recursiveTypesWithTypeof.symbols | 186 + .../reference/recursiveTypesWithTypeof.types | 200 + .../redeclareParameterInCatchBlock.symbols | 53 + .../redeclareParameterInCatchBlock.types | 57 + .../baselines/reference/redefineArray.symbols | 7 + tests/baselines/reference/redefineArray.types | 9 + .../reference/reexportedMissingAlias.symbols | 20 + .../reference/reexportedMissingAlias.types | 21 + .../relationalOperatorComparable.symbols | 59 + .../relationalOperatorComparable.types | 81 + .../relativeNamesInClassicResolution.symbols | 8 + .../relativeNamesInClassicResolution.types | 9 + .../reference/relativePathMustResolve.symbols | 8 + .../reference/relativePathMustResolve.types | 12 + .../reference/requireOfAnEmptyFile1.symbols | 9 + .../reference/requireOfAnEmptyFile1.types | 9 + .../requiredInitializedParameter1.symbols | 61 + .../requiredInitializedParameter1.types | 102 + .../requiredInitializedParameter2.symbols | 17 + .../requiredInitializedParameter2.types | 18 + .../reservedNameOnInterfaceImport.symbols | 14 + .../reservedNameOnInterfaceImport.types | 14 + ...vedNameOnModuleImportWithInterface.symbols | 16 + ...ervedNameOnModuleImportWithInterface.types | 16 + .../reference/reservedNamesInAliases.symbols | 25 + .../reference/reservedNamesInAliases.types | 30 + .../reference/reservedWords2.symbols | 34 + .../baselines/reference/reservedWords2.types | 68 + ...eclarationWhenInBaseTypeResolution.symbols | 13052 +++ ...sDeclarationWhenInBaseTypeResolution.types | 13738 +++ .../reference/restArgAssignmentCompat.symbols | 30 + .../reference/restArgAssignmentCompat.types | 44 + .../reference/restArgMissingName.symbols | 5 + .../reference/restArgMissingName.types | 5 + .../reference/restElementMustBeLast.symbols | 9 + .../reference/restElementMustBeLast.types | 20 + .../restElementWithAssignmentPattern1.symbols | 9 + .../restElementWithAssignmentPattern1.types | 18 + .../restElementWithAssignmentPattern2.symbols | 9 + .../restElementWithAssignmentPattern2.types | 18 + .../restElementWithAssignmentPattern3.symbols | 13 + .../restElementWithAssignmentPattern3.types | 22 + .../restElementWithAssignmentPattern4.symbols | 13 + .../restElementWithAssignmentPattern4.types | 22 + .../restElementWithBindingPattern.symbols | 5 + .../restElementWithBindingPattern.types | 8 + .../restElementWithBindingPattern2.symbols | 5 + .../restElementWithBindingPattern2.types | 8 + .../restElementWithInitializer1.symbols | 9 + .../restElementWithInitializer1.types | 9 + .../restElementWithInitializer2.symbols | 12 + .../restElementWithInitializer2.types | 16 + .../restElementWithNullInitializer.symbols | 22 + .../restElementWithNullInitializer.types | 25 + .../reference/restInvalidArgumentType.symbols | 160 + .../reference/restInvalidArgumentType.types | 161 + .../reference/restParamAsOptional.symbols | 9 + .../reference/restParamAsOptional.types | 10 + .../reference/restParamModifier.symbols | 8 + .../reference/restParamModifier.types | 10 + .../reference/restParamModifier2.symbols | 7 + .../reference/restParamModifier2.types | 7 + .../reference/restParameterNotLast.symbols | 6 + .../reference/restParameterNotLast.types | 6 + .../restParameterWithBindingPattern1.symbols | 6 + .../restParameterWithBindingPattern1.types | 6 + .../restParameterWithBindingPattern2.symbols | 6 + .../restParameterWithBindingPattern2.types | 6 + ...rameterWithoutAnnotationIsAnyArray.symbols | 66 + ...ParameterWithoutAnnotationIsAnyArray.types | 71 + .../restParametersOfNonArrayTypes.symbols | 68 + .../restParametersOfNonArrayTypes.types | 73 + .../restParametersOfNonArrayTypes2.symbols | 170 + .../restParametersOfNonArrayTypes2.types | 180 + ...ParametersWithArrayTypeAnnotations.symbols | 145 + ...stParametersWithArrayTypeAnnotations.types | 155 + .../restParamsWithNonRestParams.symbols | 24 + .../restParamsWithNonRestParams.types | 27 + tests/baselines/reference/restUnion3.symbols | 25 + tests/baselines/reference/restUnion3.types | 26 + .../reference/returnInConstructor1.symbols | 117 + .../reference/returnInConstructor1.types | 129 + .../reference/returnTypeParameter.symbols | 15 + .../reference/returnTypeParameter.types | 16 + .../reference/returnTypeTypeArguments.symbols | 239 + .../reference/returnTypeTypeArguments.types | 256 + .../reference/returnValueInSetter.symbols | 13 + .../reference/returnValueInSetter.types | 14 + .../reference/scanner10.1.1-8gs.symbols | 20 + .../reference/scanner10.1.1-8gs.types | 27 + .../scannerAdditiveExpression1.symbols | 3 + .../scannerAdditiveExpression1.types | 14 + .../baselines/reference/scannerClass2.symbols | 14 + tests/baselines/reference/scannerClass2.types | 22 + .../scannerES3NumericLiteral3.symbols | 3 + .../reference/scannerES3NumericLiteral3.types | 5 + .../scannerES3NumericLiteral4.symbols | 3 + .../reference/scannerES3NumericLiteral4.types | 4 + .../scannerES3NumericLiteral6.symbols | 3 + .../reference/scannerES3NumericLiteral6.types | 4 + .../scannerImportDeclaration1.symbols | 4 + .../reference/scannerImportDeclaration1.types | 6 + .../reference/scannerNumericLiteral2.symbols | 3 + .../reference/scannerNumericLiteral2.types | 4 + .../reference/scannerNumericLiteral3.symbols | 3 + .../reference/scannerNumericLiteral3.types | 5 + .../reference/scannerNumericLiteral4.symbols | 3 + .../reference/scannerNumericLiteral4.types | 4 + .../reference/scannerNumericLiteral6.symbols | 3 + .../reference/scannerNumericLiteral6.types | 4 + .../reference/scannerNumericLiteral8.symbols | 3 + .../reference/scannerNumericLiteral8.types | 5 + .../reference/scannerNumericLiteral9.symbols | 3 + .../reference/scannerNumericLiteral9.types | 5 + .../reference/scannerS7.2_A1.5_T2.symbols | 35 + .../reference/scannerS7.2_A1.5_T2.types | 52 + .../reference/scannerS7.3_A1.1_T2.symbols | 26 + .../reference/scannerS7.3_A1.1_T2.types | 35 + .../reference/scannerS7.4_A2_T2.symbols | 16 + .../reference/scannerS7.4_A2_T2.types | 16 + .../reference/scannerS7.6_A4.2_T1.symbols | 278 + .../reference/scannerS7.6_A4.2_T1.types | 476 + .../reference/scannerS7.8.3_A6.1_T1.symbols | 17 + .../reference/scannerS7.8.3_A6.1_T1.types | 17 + .../reference/scannerS7.8.4_A7.1_T4.symbols | 17 + .../reference/scannerS7.8.4_A7.1_T4.types | 17 + .../reference/scannerStringLiterals.symbols | 13 + .../reference/scannerStringLiterals.types | 32 + .../scannerUnexpectedNullCharacter1.symbols | Bin 0 -> 134 bytes .../scannerUnexpectedNullCharacter1.types | Bin 0 -> 148 bytes .../baselines/reference/scannertest1.symbols | 57 + tests/baselines/reference/scannertest1.types | 127 + ...ckExtendedClassInsidePublicMethod2.symbols | 23 + ...heckExtendedClassInsidePublicMethod2.types | 32 + ...ckExtendedClassInsideStaticMethod1.symbols | 21 + ...heckExtendedClassInsideStaticMethod1.types | 32 + .../scopeCheckInsidePublicMethod1.symbols | 13 + .../scopeCheckInsidePublicMethod1.types | 16 + .../scopeCheckInsideStaticMethod1.symbols | 26 + .../scopeCheckInsideStaticMethod1.types | 36 + .../scopeCheckStaticInitializer.symbols | 45 + .../scopeCheckStaticInitializer.types | 47 + tests/baselines/reference/scopeTests.symbols | 37 + tests/baselines/reference/scopeTests.types | 44 + .../reference/scopingInCatchBlocks.symbols | 17 + .../reference/scopingInCatchBlocks.types | 18 + tests/baselines/reference/selfRef.symbols | 30 + tests/baselines/reference/selfRef.types | 40 + ...selfReferencesInFunctionParameters.symbols | 32 + .../selfReferencesInFunctionParameters.types | 36 + .../reference/selfReferencingFile.symbols | 7 + .../reference/selfReferencingFile.types | 7 + .../reference/selfReferencingFile2.symbols | 7 + .../reference/selfReferencingFile2.types | 7 + .../reference/selfReferencingFile3.symbols | 7 + .../reference/selfReferencingFile3.types | 7 + .../selfReferencingSpreadInLoop.symbols | 13 + .../selfReferencingSpreadInLoop.types | 21 + .../semicolonsInModuleDeclarations.symbols | 21 + .../semicolonsInModuleDeclarations.types | 21 + tests/baselines/reference/separate1-1.symbols | 3 + tests/baselines/reference/separate1-1.types | 7 + .../reference/setterBeforeGetter.symbols | 31 + .../reference/setterBeforeGetter.types | 32 + .../reference/setterWithReturn.symbols | 17 + .../reference/setterWithReturn.types | 20 + .../reference/shadowPrivateMembers.symbols | 10 + .../reference/shadowPrivateMembers.types | 10 + .../reference/shadowedInternalModule.symbols | 71 + .../reference/shadowedInternalModule.types | 78 + .../reference/shadowingViaLocalValue.symbols | 20 + .../reference/shadowingViaLocalValue.types | 22 + ...owingViaLocalValueOrBindingElement.symbols | 28 + ...adowingViaLocalValueOrBindingElement.types | 43 + .../baselines/reference/shebangError.symbols | 5 + tests/baselines/reference/shebangError.types | 12 + .../shorthand-property-es5-es6.symbols | 12 + .../shorthand-property-es5-es6.types | 14 + .../shorthand-property-es6-amd.symbols | 12 + .../shorthand-property-es6-amd.types | 14 + .../shorthand-property-es6-es6.symbols | 12 + .../shorthand-property-es6-es6.types | 14 + ...thandPropertyAssignmentInES6Module.symbols | 28 + ...orthandPropertyAssignmentInES6Module.types | 32 + ...PropertyAssignmentsInDestructuring.symbols | 239 + ...ndPropertyAssignmentsInDestructuring.types | 425 + ...ertyAssignmentsInDestructuring_ES6.symbols | 239 + ...opertyAssignmentsInDestructuring_ES6.types | 425 + .../slashBeforeVariableDeclaration1.symbols | 4 + .../slashBeforeVariableDeclaration1.types | 4 + .../reference/sourceMap-LineBreaks.symbols | 41 +- .../reference/sourceMap-LineBreaks.types | 41 +- .../reference/sourceMapSample.symbols | 100 + .../baselines/reference/sourceMapSample.types | 130 + .../sourceMapValidationEnums.symbols | 31 + .../reference/sourceMapValidationEnums.types | 33 + .../reference/sourceMapValidationFor.symbols | 66 + .../reference/sourceMapValidationFor.types | 119 + .../sourceMapValidationForIn.symbols | 29 + .../reference/sourceMapValidationForIn.types | 45 + .../sourceMapValidationStatements.symbols | 197 + .../sourceMapValidationStatements.types | 289 + ...reQuestionMarkInPropertyAssignment.symbols | 5 + ...foreQuestionMarkInPropertyAssignment.types | 7 + ...lizedSignatureAsCallbackParameter1.symbols | 32 + ...ializedSignatureAsCallbackParameter1.types | 41 + ...otSubtypeOfNonSpecializedSignature.symbols | 186 + ...sNotSubtypeOfNonSpecializedSignature.types | 186 + ...lingSuggestionLeadingUnderscores01.symbols | 28 + ...ellingSuggestionLeadingUnderscores01.types | 33 + .../spreadInvalidArgumentType.symbols | 161 + .../reference/spreadInvalidArgumentType.types | 181 + .../baselines/reference/spreadMethods.symbols | 109 + tests/baselines/reference/spreadMethods.types | 131 + .../baselines/reference/spreadUnion3.symbols | 52 + tests/baselines/reference/spreadUnion3.types | 66 + .../reference/standaloneBreak.symbols | 3 + .../baselines/reference/standaloneBreak.types | 3 + .../reference/staticAsIdentifier.symbols | 8 + .../reference/staticAsIdentifier.types | 8 + .../reference/staticClassMemberError.symbols | 24 + .../reference/staticClassMemberError.types | 27 + .../reference/staticClassProps.symbols | 13 + .../reference/staticClassProps.types | 14 + .../baselines/reference/staticGetter1.symbols | 13 + tests/baselines/reference/staticGetter1.types | 13 + .../reference/staticGetterAndSetter.symbols | 12 + .../reference/staticGetterAndSetter.types | 13 + .../baselines/reference/staticIndexer.symbols | 7 + tests/baselines/reference/staticIndexer.types | 7 + .../reference/staticIndexers.symbols | 24 + .../baselines/reference/staticIndexers.types | 25 + .../staticInstanceResolution4.symbols | 11 + .../reference/staticInstanceResolution4.types | 14 + .../staticInstanceResolution5.symbols | 30 + .../reference/staticInstanceResolution5.types | 36 + ...ssignsToConstructorFunctionMembers.symbols | 38 + ...rAssignsToConstructorFunctionMembers.types | 48 + .../staticMemberExportAccess.symbols | 68 + .../reference/staticMemberExportAccess.types | 81 + ...blicMemberOfAnotherClassAssignment.symbols | 71 + ...PublicMemberOfAnotherClassAssignment.types | 84 + ...aticMembersUsingClassTypeParameter.symbols | 39 + ...staticMembersUsingClassTypeParameter.types | 45 + ...aticMethodReferencingTypeArgument1.symbols | 50 + ...staticMethodReferencingTypeArgument1.types | 58 + ...hodsReferencingClassTypeParameters.symbols | 10 + ...ethodsReferencingClassTypeParameters.types | 11 + .../staticModifierAlreadySeen.symbols | 10 + .../reference/staticModifierAlreadySeen.types | 11 + .../reference/staticMustPrecedePublic.symbols | 11 + .../reference/staticMustPrecedePublic.types | 11 + .../reference/staticOffOfInstance1.symbols | 13 + .../reference/staticOffOfInstance1.types | 16 + .../reference/staticOffOfInstance2.symbols | 20 + .../reference/staticOffOfInstance2.types | 24 + .../reference/staticPropSuper.symbols | 59 + .../baselines/reference/staticPropSuper.types | 68 + .../staticPropertyNameConflicts.symbols | 362 + .../staticPropertyNameConflicts.types | 372 + .../staticPropertyNotInClassType.symbols | 114 + .../staticPropertyNotInClassType.types | 139 + .../reference/staticPrototypeProperty.symbols | 14 + .../reference/staticPrototypeProperty.types | 14 + .../reference/staticVisibility.symbols | 61 + .../reference/staticVisibility.types | 86 + tests/baselines/reference/statics.symbols | 131 + tests/baselines/reference/statics.types | 176 + .../reference/staticsInAFunction.symbols | 9 + .../reference/staticsInAFunction.types | 23 + .../staticsInConstructorBodies.symbols | 12 + .../staticsInConstructorBodies.types | 13 + .../staticsNotInScopeInClodule.symbols | 14 + .../staticsNotInScopeInClodule.types | 16 + .../reference/strictModeInConstructor.symbols | 100 + .../reference/strictModeInConstructor.types | 122 + .../reference/strictModeReservedWord.symbols | 76 + .../reference/strictModeReservedWord.types | 104 + .../reference/strictModeReservedWord2.symbols | 55 + .../reference/strictModeReservedWord2.types | 57 + ...ModeReservedWordInClassDeclaration.symbols | 69 + ...ctModeReservedWordInClassDeclaration.types | 86 + ...ictModeReservedWordInDestructuring.symbols | 41 + ...trictModeReservedWordInDestructuring.types | 62 + ...servedWordInImportEqualDeclaration.symbols | 5 + ...ReservedWordInImportEqualDeclaration.types | 7 + ...odeReservedWordInModuleDeclaration.symbols | 17 + ...tModeReservedWordInModuleDeclaration.types | 19 + .../strictModeWordInImportDeclaration.symbols | 12 + .../strictModeWordInImportDeclaration.types | 14 + .../reference/stringEnumLiteralTypes1.symbols | 18 +- .../reference/stringEnumLiteralTypes2.symbols | 18 +- .../reference/stringEnumLiteralTypes3.symbols | 514 + .../reference/stringEnumLiteralTypes3.types | 573 + .../stringIndexerAndConstructor.symbols | 24 + .../stringIndexerAndConstructor.types | 24 + .../stringIndexerAndConstructor1.symbols | 9 + .../stringIndexerAndConstructor1.types | 9 + .../stringIndexerAssignments1.symbols | 23 + .../reference/stringIndexerAssignments1.types | 25 + .../stringIndexerAssignments2.symbols | 48 + .../reference/stringIndexerAssignments2.types | 50 + ...exerConstrainsPropertyDeclarations.symbols | 174 + ...ndexerConstrainsPropertyDeclarations.types | 198 + ...xerConstrainsPropertyDeclarations2.symbols | 99 + ...dexerConstrainsPropertyDeclarations2.types | 102 + ...eralTypesAndLogicalOrExpressions01.symbols | 19 +- ...iteralTypesAndLogicalOrExpressions01.types | 5 +- ...alTypesInImplementationSignatures2.symbols | 73 + ...eralTypesInImplementationSignatures2.types | 74 + ...teralTypesInVariableDeclarations01.symbols | 43 + ...LiteralTypesInVariableDeclarations01.types | 59 + ...iteralTypesOverloadAssignability01.symbols | 39 + ...gLiteralTypesOverloadAssignability01.types | 43 + ...iteralTypesOverloadAssignability02.symbols | 39 + ...gLiteralTypesOverloadAssignability02.types | 43 + .../stringLiteralTypesOverloads01.symbols | 36 +- .../stringLiteralTypesOverloads02.symbols | 36 +- .../stringLiteralTypesOverloads05.symbols | 44 + .../stringLiteralTypesOverloads05.types | 44 + ...gLiteralTypesWithTemplateStrings02.symbols | 8 + ...ingLiteralTypesWithTemplateStrings02.types | 11 + ...LiteralTypesWithVariousOperators02.symbols | 68 + ...ngLiteralTypesWithVariousOperators02.types | 91 + ...sAssertionsInEqualityComparisons02.symbols | 18 + ...alsAssertionsInEqualityComparisons02.types | 37 + .../reference/stringLiteralsErrors.symbols | 52 + .../reference/stringLiteralsErrors.types | 71 + ...stringLiteralsWithEqualityChecks01.symbols | 75 + .../stringLiteralsWithEqualityChecks01.types | 123 + ...stringLiteralsWithEqualityChecks02.symbols | 75 + .../stringLiteralsWithEqualityChecks02.types | 123 + ...stringLiteralsWithEqualityChecks03.symbols | 90 + .../stringLiteralsWithEqualityChecks03.types | 138 + ...stringLiteralsWithEqualityChecks04.symbols | 90 + .../stringLiteralsWithEqualityChecks04.types | 138 + ...ringLiteralsWithSwitchStatements01.symbols | 23 + ...stringLiteralsWithSwitchStatements01.types | 27 + ...ringLiteralsWithSwitchStatements02.symbols | 43 + ...stringLiteralsWithSwitchStatements02.types | 67 + ...ringLiteralsWithSwitchStatements03.symbols | 53 + ...stringLiteralsWithSwitchStatements03.types | 93 + ...stringLiteralsWithSwitchStatements04.types | 42 +- .../stringNamedPropertyDuplicates.symbols | 30 + .../stringNamedPropertyDuplicates.types | 34 + .../stringPropertyAccessWithError.symbols | 9 + .../stringPropertyAccessWithError.types | 13 + .../reference/subtypesOfTypeParameter.symbols | 340 + .../reference/subtypesOfTypeParameter.types | 454 + ...ypesOfTypeParameterWithConstraints.symbols | 587 + ...btypesOfTypeParameterWithConstraints.types | 587 + ...pesOfTypeParameterWithConstraints4.symbols | 268 + ...typesOfTypeParameterWithConstraints4.types | 298 + ...eParameterWithRecursiveConstraints.symbols | 621 + ...ypeParameterWithRecursiveConstraints.types | 687 + .../reference/subtypesOfUnion.symbols | 191 + .../baselines/reference/subtypesOfUnion.types | 193 + .../subtypingWithCallSignaturesA.symbols | 12 + .../subtypingWithCallSignaturesA.types | 15 + ...llSignaturesWithOptionalParameters.symbols | 193 + ...CallSignaturesWithOptionalParameters.types | 193 + ...thCallSignaturesWithRestParameters.symbols | 315 + ...WithCallSignaturesWithRestParameters.types | 315 + ...ignaturesWithSpecializedSignatures.symbols | 175 + ...lSignaturesWithSpecializedSignatures.types | 175 + ...ctSignaturesWithOptionalParameters.symbols | 193 + ...ructSignaturesWithOptionalParameters.types | 193 + ...ignaturesWithSpecializedSignatures.symbols | 175 + ...tSignaturesWithSpecializedSignatures.types | 175 + ...llSignaturesWithOptionalParameters.symbols | 813 + ...CallSignaturesWithOptionalParameters.types | 813 + ...ctSignaturesWithOptionalParameters.symbols | 813 + ...ructSignaturesWithOptionalParameters.types | 813 + .../subtypingWithNumericIndexer.symbols | 100 + .../subtypingWithNumericIndexer.types | 100 + .../subtypingWithNumericIndexer2.symbols | 112 + .../subtypingWithNumericIndexer2.types | 112 + .../subtypingWithNumericIndexer3.symbols | 112 + .../subtypingWithNumericIndexer3.types | 112 + .../subtypingWithNumericIndexer4.symbols | 66 + .../subtypingWithNumericIndexer4.types | 66 + .../subtypingWithNumericIndexer5.symbols | 112 + .../subtypingWithNumericIndexer5.types | 112 + .../subtypingWithObjectMembers.symbols | 148 + .../subtypingWithObjectMembers.types | 148 + .../subtypingWithObjectMembers2.symbols | 154 + .../subtypingWithObjectMembers2.types | 154 + .../subtypingWithObjectMembers3.symbols | 159 + .../subtypingWithObjectMembers3.types | 159 + .../subtypingWithObjectMembers5.symbols | 121 + .../subtypingWithObjectMembers5.types | 121 + ...pingWithObjectMembersAccessibility.symbols | 64 + ...typingWithObjectMembersAccessibility.types | 64 + ...ingWithObjectMembersAccessibility2.symbols | 119 + ...ypingWithObjectMembersAccessibility2.types | 119 + ...ypingWithObjectMembersOptionality2.symbols | 75 + ...btypingWithObjectMembersOptionality2.types | 77 + .../subtypingWithStringIndexer.symbols | 101 + .../subtypingWithStringIndexer.types | 101 + .../subtypingWithStringIndexer2.symbols | 112 + .../subtypingWithStringIndexer2.types | 112 + .../subtypingWithStringIndexer3.symbols | 112 + .../subtypingWithStringIndexer3.types | 112 + .../subtypingWithStringIndexer4.symbols | 66 + .../subtypingWithStringIndexer4.types | 66 + tests/baselines/reference/super.symbols | 80 + tests/baselines/reference/super.types | 99 + tests/baselines/reference/super1.symbols | 120 + tests/baselines/reference/super1.types | 143 + tests/baselines/reference/superAccess.symbols | 38 + tests/baselines/reference/superAccess.types | 45 + .../baselines/reference/superAccess2.symbols | 60 + tests/baselines/reference/superAccess2.types | 88 + .../reference/superCallArgsMustMatch.symbols | 39 + .../reference/superCallArgsMustMatch.types | 41 + .../reference/superCallAssignResult.symbols | 21 + .../reference/superCallAssignResult.types | 25 + .../superCallBeforeThisAccessing3.symbols | 35 + .../superCallBeforeThisAccessing3.types | 38 + .../superCallBeforeThisAccessing4.symbols | 31 + .../superCallBeforeThisAccessing4.types | 38 + .../superCallBeforeThisAccessing6.symbols | 21 + .../superCallBeforeThisAccessing6.types | 22 + .../superCallBeforeThisAccessing7.symbols | 30 + .../superCallBeforeThisAccessing7.types | 32 + ...ithIncorrectNumberOfTypeArguments1.symbols | 24 + ...tWithIncorrectNumberOfTypeArguments1.types | 28 + ...GenericTypeButWithNoTypeArguments1.symbols | 24 + ...omGenericTypeButWithNoTypeArguments1.types | 28 + ...onGenericTypeButWithTypeArguments1.symbols | 20 + ...sNonGenericTypeButWithTypeArguments1.types | 24 + ...perCallFromClassThatHasNoBaseType1.symbols | 19 + ...superCallFromClassThatHasNoBaseType1.types | 23 + .../reference/superCallFromFunction1.symbols | 9 + .../reference/superCallFromFunction1.types | 13 + ...perCallInConstructorWithNoBaseType.symbols | 20 + ...superCallInConstructorWithNoBaseType.types | 24 + .../superCallInNonStaticMethod.symbols | 104 + .../superCallInNonStaticMethod.types | 121 + .../reference/superCallInStaticMethod.symbols | 96 + .../reference/superCallInStaticMethod.types | 110 + .../superCallInsideClassDeclaration.symbols | 26 + .../superCallInsideClassDeclaration.types | 27 + .../superCallInsideClassExpression.symbols | 26 + .../superCallInsideClassExpression.types | 28 + .../superCallOutsideConstructor.symbols | 37 + .../superCallOutsideConstructor.types | 47 + ...uperCallParameterContextualTyping2.symbols | 26 + .../superCallParameterContextualTyping2.types | 30 + .../superCallWithMissingBaseClass.symbols | 16 + .../superCallWithMissingBaseClass.types | 25 + .../reference/superCallsInConstructor.symbols | 36 + .../reference/superCallsInConstructor.types | 46 + tests/baselines/reference/superErrors.symbols | 94 + tests/baselines/reference/superErrors.types | 149 + .../superInConstructorParam1.symbols | 19 + .../reference/superInConstructorParam1.types | 24 + .../reference/superInLambdas.symbols | 140 + .../baselines/reference/superInLambdas.types | 177 + .../superInObjectLiterals_ES5.symbols | 109 + .../reference/superInObjectLiterals_ES5.types | 178 + .../superInObjectLiterals_ES6.symbols | 109 + .../reference/superInObjectLiterals_ES6.types | 178 + .../baselines/reference/superNewCall1.symbols | 27 + tests/baselines/reference/superNewCall1.types | 30 + .../reference/superPropertyAccess.symbols | 101 + .../reference/superPropertyAccess.types | 115 + .../reference/superPropertyAccess1.symbols | 66 + .../reference/superPropertyAccess1.types | 72 + .../reference/superPropertyAccess2.symbols | 60 + .../reference/superPropertyAccess2.types | 72 + .../superPropertyAccessInSuperCall01.symbols | 23 + .../superPropertyAccessInSuperCall01.types | 26 + .../reference/superPropertyAccess_ES5.symbols | 79 + .../reference/superPropertyAccess_ES5.types | 88 + ...opertyInConstructorBeforeSuperCall.symbols | 36 + ...PropertyInConstructorBeforeSuperCall.types | 41 + .../superSymbolIndexedAccess3.symbols | 29 + .../reference/superSymbolIndexedAccess3.types | 34 + .../superSymbolIndexedAccess4.symbols | 17 + .../reference/superSymbolIndexedAccess4.types | 22 + .../reference/superWithTypeArgument.symbols | 17 + .../reference/superWithTypeArgument.types | 20 + .../reference/superWithTypeArgument2.symbols | 25 + .../reference/superWithTypeArgument2.types | 28 + .../reference/superWithTypeArgument3.symbols | 37 + .../reference/superWithTypeArgument3.types | 42 + ...object-literal-getters-and-setters.symbols | 55 + ...e-object-literal-getters-and-setters.types | 75 + .../reference/switchAssignmentCompat.symbols | 9 + .../reference/switchAssignmentCompat.types | 11 + .../reference/switchBreakStatements.symbols | 3 +- .../reference/switchBreakStatements.types | 23 +- .../switchCaseCircularRefeference.symbols | 22 + .../switchCaseCircularRefeference.types | 22 + .../switchCaseWithIntersectionTypes01.symbols | 46 + .../switchCaseWithIntersectionTypes01.types | 46 + .../switchCaseWithUnionTypes01.symbols | 46 + .../switchCaseWithUnionTypes01.types | 46 + tests/baselines/reference/switchCases.types | 2 +- .../switchCasesExpressionTypeMismatch.symbols | 28 + .../switchCasesExpressionTypeMismatch.types | 41 + .../reference/switchStatements.symbols | 115 + .../reference/switchStatements.types | 184 + ...itchStatementsWithMultipleDefaults.symbols | 44 + ...switchStatementsWithMultipleDefaults.types | 58 + ...tchStatementsWithMultipleDefaults1.symbols | 18 + ...witchStatementsWithMultipleDefaults1.types | 26 + .../reference/symbolDeclarationEmit12.symbols | 46 + .../reference/symbolDeclarationEmit12.types | 46 + .../reference/symbolProperty10.symbols | 34 + .../reference/symbolProperty10.types | 36 + .../reference/symbolProperty12.symbols | 33 + .../reference/symbolProperty12.types | 35 + .../reference/symbolProperty17.symbols | 26 + .../reference/symbolProperty17.types | 27 + .../reference/symbolProperty21.symbols | 51 + .../reference/symbolProperty21.types | 56 + .../reference/symbolProperty24.symbols | 22 + .../reference/symbolProperty24.types | 23 + .../reference/symbolProperty25.symbols | 22 + .../reference/symbolProperty25.types | 23 + .../reference/symbolProperty29.symbols | 16 + .../reference/symbolProperty29.types | 18 + .../reference/symbolProperty3.symbols | 20 + .../baselines/reference/symbolProperty3.types | 23 + .../reference/symbolProperty30.symbols | 16 + .../reference/symbolProperty30.types | 18 + .../reference/symbolProperty31.symbols | 21 + .../reference/symbolProperty31.types | 23 + .../reference/symbolProperty32.symbols | 21 + .../reference/symbolProperty32.types | 23 + .../reference/symbolProperty33.symbols | 21 + .../reference/symbolProperty33.types | 23 + .../reference/symbolProperty34.symbols | 21 + .../reference/symbolProperty34.types | 23 + .../reference/symbolProperty35.symbols | 25 + .../reference/symbolProperty35.types | 25 + .../reference/symbolProperty36.symbols | 14 + .../reference/symbolProperty36.types | 17 + .../reference/symbolProperty39.symbols | 35 + .../reference/symbolProperty39.types | 35 + .../reference/symbolProperty42.symbols | 26 + .../reference/symbolProperty42.types | 26 + .../reference/symbolProperty43.symbols | 16 + .../reference/symbolProperty43.types | 16 + .../reference/symbolProperty44.symbols | 19 + .../reference/symbolProperty44.types | 21 + .../reference/symbolProperty46.symbols | 32 + .../reference/symbolProperty46.types | 43 + .../reference/symbolProperty47.symbols | 32 + .../reference/symbolProperty47.types | 43 + .../reference/symbolProperty48.symbols | 14 + .../reference/symbolProperty48.types | 16 + .../reference/symbolProperty49.symbols | 14 + .../reference/symbolProperty49.types | 16 + .../reference/symbolProperty52.symbols | 16 + .../reference/symbolProperty52.types | 25 + .../reference/symbolProperty53.symbols | 17 + .../reference/symbolProperty53.types | 20 + .../reference/symbolProperty54.symbols | 10 + .../reference/symbolProperty54.types | 12 + .../reference/symbolProperty58.symbols | 16 + .../reference/symbolProperty58.types | 18 + .../reference/symbolProperty59.symbols | 9 + .../reference/symbolProperty59.types | 9 + .../reference/symbolProperty7.symbols | 19 + .../baselines/reference/symbolProperty7.types | 25 + .../reference/symbolProperty9.symbols | 34 + .../baselines/reference/symbolProperty9.types | 36 + tests/baselines/reference/symbolType1.symbols | 17 + tests/baselines/reference/symbolType1.types | 31 + .../baselines/reference/symbolType10.symbols | 25 + tests/baselines/reference/symbolType10.types | 34 + .../baselines/reference/symbolType12.symbols | 99 + tests/baselines/reference/symbolType12.types | 141 + .../baselines/reference/symbolType13.symbols | 19 + tests/baselines/reference/symbolType13.types | 21 + .../baselines/reference/symbolType14.symbols | 4 + tests/baselines/reference/symbolType14.types | 5 + .../baselines/reference/symbolType15.symbols | 16 + tests/baselines/reference/symbolType15.types | 18 + tests/baselines/reference/symbolType2.symbols | 11 + tests/baselines/reference/symbolType2.types | 15 + .../baselines/reference/symbolType20.symbols | 4 + tests/baselines/reference/symbolType20.types | 4 + tests/baselines/reference/symbolType3.symbols | 41 + tests/baselines/reference/symbolType3.types | 60 + tests/baselines/reference/symbolType4.symbols | 13 + tests/baselines/reference/symbolType4.types | 17 + tests/baselines/reference/symbolType5.symbols | 25 + tests/baselines/reference/symbolType5.types | 34 + tests/baselines/reference/symbolType6.symbols | 50 + tests/baselines/reference/symbolType6.types | 78 + tests/baselines/reference/symbolType7.symbols | 28 + tests/baselines/reference/symbolType7.types | 39 + tests/baselines/reference/symbolType8.symbols | 42 + tests/baselines/reference/symbolType8.types | 65 + tests/baselines/reference/symbolType9.symbols | 35 + tests/baselines/reference/symbolType9.types | 49 + .../baselines/reference/syntaxErrors.symbols | 29 + tests/baselines/reference/syntaxErrors.types | 35 + .../reference/systemExportAssignment2.symbols | 11 + .../reference/systemExportAssignment2.types | 12 + .../reference/systemModule10.symbols | 29 + .../baselines/reference/systemModule10.types | 29 + .../reference/systemModule10_ES5.symbols | 29 + .../reference/systemModule10_ES5.types | 29 + .../reference/systemModule11.symbols | 67 + .../baselines/reference/systemModule11.types | 67 + .../reference/systemModule12.symbols | 5 + .../baselines/reference/systemModule12.types | 5 + .../reference/systemModule14.symbols | 21 + .../baselines/reference/systemModule14.types | 22 + .../reference/systemModule16.symbols | 34 + .../baselines/reference/systemModule16.types | 38 + .../baselines/reference/systemModule2.symbols | 7 + tests/baselines/reference/systemModule2.types | 8 + .../baselines/reference/systemModule9.symbols | 54 + tests/baselines/reference/systemModule9.types | 68 + ...mplateStringsTypeArgumentInference.symbols | 345 + ...TemplateStringsTypeArgumentInference.types | 467 + ...ateStringsTypeArgumentInferenceES6.symbols | 345 + ...plateStringsTypeArgumentInferenceES6.types | 467 + ...teStringsWithIncompatibleTypedTags.symbols | 80 + ...lateStringsWithIncompatibleTypedTags.types | 138 + ...tringsWithIncompatibleTypedTagsES6.symbols | 80 + ...eStringsWithIncompatibleTypedTagsES6.types | 138 + ...lateStringsWithOverloadResolution1.symbols | 82 + ...mplateStringsWithOverloadResolution1.types | 126 + ...StringsWithOverloadResolution1_ES6.symbols | 82 + ...teStringsWithOverloadResolution1_ES6.types | 126 + ...lateStringsWithOverloadResolution3.symbols | 231 + ...mplateStringsWithOverloadResolution3.types | 322 + ...StringsWithOverloadResolution3_ES6.symbols | 231 + ...teStringsWithOverloadResolution3_ES6.types | 322 + ...xpressionsInSubstitutionExpression.symbols | 11 + ...nExpressionsInSubstitutionExpression.types | 16 + ...essionsInSubstitutionExpressionES6.symbols | 11 + ...pressionsInSubstitutionExpressionES6.types | 16 + ...taggedTemplateWithConstructableTag01.types | 2 +- ...taggedTemplateWithConstructableTag02.types | 2 +- ...hIncompleteNoSubstitutionTemplate1.symbols | 13 + ...ithIncompleteNoSubstitutionTemplate1.types | 15 + ...hIncompleteNoSubstitutionTemplate2.symbols | 13 + ...ithIncompleteNoSubstitutionTemplate2.types | 15 + ...WithIncompleteTemplateExpressions1.symbols | 13 + ...esWithIncompleteTemplateExpressions1.types | 16 + ...WithIncompleteTemplateExpressions2.symbols | 13 + ...esWithIncompleteTemplateExpressions2.types | 17 + ...WithIncompleteTemplateExpressions3.symbols | 13 + ...esWithIncompleteTemplateExpressions3.types | 17 + ...WithIncompleteTemplateExpressions4.symbols | 13 + ...esWithIncompleteTemplateExpressions4.types | 18 + ...WithIncompleteTemplateExpressions5.symbols | 13 + ...esWithIncompleteTemplateExpressions5.types | 18 + ...WithIncompleteTemplateExpressions6.symbols | 13 + ...esWithIncompleteTemplateExpressions6.types | 17 + .../reference/targetTypeBaseCalls.symbols | 36 + .../reference/targetTypeBaseCalls.types | 48 + .../reference/targetTypeCastTest.symbols | 60 + .../reference/targetTypeCastTest.types | 73 + .../reference/targetTypeTest1.symbols | 176 + .../baselines/reference/targetTypeTest1.types | 244 + .../reference/targetTypeTest3.symbols | 25 + .../baselines/reference/targetTypeTest3.types | 31 + .../reference/targetTypeVoidFunc.symbols | 19 + .../reference/targetTypeVoidFunc.types | 26 + ...teStringBinaryOperationsES6Invalid.symbols | 289 + ...lateStringBinaryOperationsES6Invalid.types | 817 + ...plateStringBinaryOperationsInvalid.symbols | 289 + ...emplateStringBinaryOperationsInvalid.types | 817 + .../templateStringInCallExpression.symbols | 3 + .../templateStringInCallExpression.types | 11 + .../templateStringInCallExpressionES6.symbols | 3 + .../templateStringInCallExpressionES6.types | 11 + .../templateStringInDivision.symbols | 4 + .../reference/templateStringInDivision.types | 8 + ...plateStringInFunctionParameterType.symbols | 15 + ...emplateStringInFunctionParameterType.types | 16 + ...teStringInFunctionParameterTypeES6.symbols | 15 + ...lateStringInFunctionParameterTypeES6.types | 16 + .../templateStringInInstanceOf.symbols | 5 + .../templateStringInInstanceOf.types | 8 + .../templateStringInInstanceOfES6.symbols | 5 + .../templateStringInInstanceOfES6.types | 8 + .../templateStringInModuleName.symbols | 7 + .../templateStringInModuleName.types | 15 + .../templateStringInModuleNameES6.symbols | 7 + .../templateStringInModuleNameES6.types | 15 + .../reference/templateStringInModulo.symbols | 4 + .../reference/templateStringInModulo.types | 8 + .../templateStringInModuloES6.symbols | 4 + .../reference/templateStringInModuloES6.types | 8 + .../templateStringInMultiplication.symbols | 4 + .../templateStringInMultiplication.types | 8 + .../templateStringInMultiplicationES6.symbols | 4 + .../templateStringInMultiplicationES6.types | 8 + .../templateStringInNewExpression.symbols | 3 + .../templateStringInNewExpression.types | 11 + .../templateStringInNewExpressionES6.symbols | 3 + .../templateStringInNewExpressionES6.types | 11 + .../templateStringInNewOperator.symbols | 4 + .../templateStringInNewOperator.types | 7 + .../templateStringInNewOperatorES6.symbols | 4 + .../templateStringInNewOperatorES6.types | 7 + .../templateStringInObjectLiteral.symbols | 9 + .../templateStringInObjectLiteral.types | 15 + .../templateStringInObjectLiteralES6.symbols | 9 + .../templateStringInObjectLiteralES6.types | 15 + .../templateStringInPropertyName1.symbols | 6 + .../templateStringInPropertyName1.types | 10 + .../templateStringInPropertyName2.symbols | 6 + .../templateStringInPropertyName2.types | 12 + .../templateStringInPropertyNameES6_1.symbols | 6 + .../templateStringInPropertyNameES6_1.types | 10 + .../templateStringInPropertyNameES6_2.symbols | 6 + .../templateStringInPropertyNameES6_2.types | 12 + .../templateStringInTaggedTemplate.symbols | 3 + .../templateStringInTaggedTemplate.types | 9 + .../templateStringInTaggedTemplateES6.symbols | 3 + .../templateStringInTaggedTemplateES6.types | 9 + .../templateStringUnterminated1.symbols | 3 + .../templateStringUnterminated1.types | 4 + .../templateStringUnterminated1_ES6.symbols | 3 + .../templateStringUnterminated1_ES6.types | 4 + .../templateStringUnterminated2.symbols | 3 + .../templateStringUnterminated2.types | 4 + .../templateStringUnterminated2_ES6.symbols | 3 + .../templateStringUnterminated2_ES6.types | 4 + .../templateStringUnterminated3.symbols | 3 + .../templateStringUnterminated3.types | 4 + .../templateStringUnterminated3_ES6.symbols | 3 + .../templateStringUnterminated3_ES6.types | 4 + .../templateStringUnterminated4.symbols | 3 + .../templateStringUnterminated4.types | 4 + .../templateStringUnterminated4_ES6.symbols | 3 + .../templateStringUnterminated4_ES6.types | 4 + .../templateStringUnterminated5.symbols | 3 + .../templateStringUnterminated5.types | 4 + .../templateStringUnterminated5_ES6.symbols | 3 + .../templateStringUnterminated5_ES6.types | 4 + ...mplateStringWithEmbeddedInstanceOf.symbols | 5 + ...templateStringWithEmbeddedInstanceOf.types | 8 + ...ateStringWithEmbeddedInstanceOfES6.symbols | 5 + ...plateStringWithEmbeddedInstanceOfES6.types | 8 + ...teStringWithEmbeddedNewOperatorES6.symbols | 2 +- ...lateStringWithEmbeddedYieldKeyword.symbols | 9 + ...mplateStringWithEmbeddedYieldKeyword.types | 12 + ...teStringsArrayTypeDefinedInES5Mode.symbols | 19 + ...lateStringsArrayTypeDefinedInES5Mode.types | 27 + ...eStringsArrayTypeNotDefinedES5Mode.symbols | 15 + ...ateStringsArrayTypeNotDefinedES5Mode.types | 23 + ...StringsArrayTypeRedefinedInES6Mode.symbols | 19 + ...teStringsArrayTypeRedefinedInES6Mode.types | 27 + ...xpressionsInSubstitutionExpression.symbols | 5 + ...nExpressionsInSubstitutionExpression.types | 9 + ...essionsInSubstitutionExpressionES6.symbols | 5 + ...pressionsInSubstitutionExpressionES6.types | 9 + tests/baselines/reference/thisBinding.symbols | 52 + tests/baselines/reference/thisBinding.types | 62 + ...ionInCallExpressionWithTypeArguments.types | 10 +- .../reference/thisInAccessors.symbols | 61 + .../baselines/reference/thisInAccessors.types | 68 + ...nArrowFunctionInStaticInitializer1.symbols | 17 + ...sInArrowFunctionInStaticInitializer1.types | 19 + .../thisInConstructorParameter1.symbols | 13 + .../thisInConstructorParameter1.types | 13 + .../thisInConstructorParameter2.symbols | 34 + .../thisInConstructorParameter2.types | 34 + .../reference/thisInInvalidContexts.symbols | 86 + .../reference/thisInInvalidContexts.types | 96 + ...hisInInvalidContextsExternalModule.symbols | 86 + .../thisInInvalidContextsExternalModule.types | 96 + .../baselines/reference/thisInModule.symbols | 9 + tests/baselines/reference/thisInModule.types | 14 + .../reference/thisInObjectLiterals.symbols | 1 + .../reference/thisInObjectLiterals.types | 2 +- .../reference/thisInOuterClassBody.symbols | 48 + .../reference/thisInOuterClassBody.types | 53 + .../baselines/reference/thisInStatics.symbols | 23 + tests/baselines/reference/thisInStatics.types | 23 + .../reference/thisInSuperCall.symbols | 45 + .../baselines/reference/thisInSuperCall.types | 49 + .../reference/thisInSuperCall1.symbols | 21 + .../reference/thisInSuperCall1.types | 22 + .../reference/thisInSuperCall2.symbols | 37 + .../reference/thisInSuperCall2.types | 40 + .../reference/thisInSuperCall3.symbols | 22 + .../reference/thisInSuperCall3.types | 24 + tests/baselines/reference/thisKeyword.symbols | 6 + tests/baselines/reference/thisKeyword.types | 11 + .../reference/thisTypeErrors.symbols | 134 + .../baselines/reference/thisTypeErrors.types | 139 + .../reference/thisTypeErrors2.symbols | 33 + .../baselines/reference/thisTypeErrors2.types | 35 + .../thisTypeInAccessorsNegative.symbols | 53 + .../thisTypeInAccessorsNegative.types | 59 + .../thisTypeInFunctionsNegative.symbols | 664 + .../thisTypeInFunctionsNegative.types | 791 + .../reference/thisWhenTypeCheckFails.symbols | 19 + .../reference/thisWhenTypeCheckFails.types | 21 + ..._inside-enum-should-not-be-allowed.symbols | 18 + ...is_inside-enum-should-not-be-allowed.types | 20 + ...object-literal-getters-and-setters.symbols | 32 + ...e-object-literal-getters-and-setters.types | 46 + .../reference/throwWithoutNewLine1.symbols | 3 + .../reference/throwWithoutNewLine1.types | 4 + .../reference/throwWithoutNewLine2.symbols | 4 + .../reference/throwWithoutNewLine2.types | 5 + .../reference/tooManyTypeParameters1.symbols | 33 + .../reference/tooManyTypeParameters1.types | 37 + .../topLevelFileModuleMissing.symbols | 8 + .../reference/topLevelFileModuleMissing.types | 12 + .../reference/topLevelLambda.symbols | 8 + .../baselines/reference/topLevelLambda.types | 12 + .../topLevelModuleDeclarationAndFile.symbols | 22 + .../topLevelModuleDeclarationAndFile.types | 29 + ...ngCommaInHeterogenousArrayLiteral1.symbols | 24 + ...lingCommaInHeterogenousArrayLiteral1.types | 36 + .../reference/trailingCommasInGetter.symbols | 8 + .../reference/trailingCommasInGetter.types | 9 + .../reference/tsxAttributeErrors.symbols | 50 + .../reference/tsxAttributeErrors.types | 59 + .../tsxAttributeInvalidNames.symbols | 25 + .../reference/tsxAttributeInvalidNames.types | 40 + .../reference/tsxAttributeResolution1.symbols | 86 + .../reference/tsxAttributeResolution1.types | 105 + .../tsxAttributeResolution10.symbols | 49 + .../reference/tsxAttributeResolution10.types | 53 + .../tsxAttributeResolution11.symbols | 47 + .../reference/tsxAttributeResolution11.types | 48 + .../tsxAttributeResolution12.symbols | 117 + .../reference/tsxAttributeResolution12.types | 119 + .../tsxAttributeResolution14.symbols | 65 + .../reference/tsxAttributeResolution14.types | 77 + .../tsxAttributeResolution15.symbols | 40 + .../reference/tsxAttributeResolution15.types | 49 + .../reference/tsxAttributeResolution2.symbols | 46 + .../reference/tsxAttributeResolution2.types | 56 + .../reference/tsxAttributeResolution3.symbols | 98 + .../reference/tsxAttributeResolution3.types | 124 + .../reference/tsxAttributeResolution4.symbols | 36 + .../reference/tsxAttributeResolution4.types | 45 + .../reference/tsxAttributeResolution5.symbols | 76 + .../reference/tsxAttributeResolution5.types | 83 + .../reference/tsxAttributeResolution6.symbols | 46 + .../reference/tsxAttributeResolution6.types | 53 + .../reference/tsxAttributeResolution7.symbols | 33 + .../reference/tsxAttributeResolution7.types | 41 + .../reference/tsxAttributeResolution9.symbols | 46 + .../reference/tsxAttributeResolution9.types | 49 + .../tsxDefaultAttributesResolution3.symbols | 32 + .../tsxDefaultAttributesResolution3.types | 35 + .../reference/tsxDynamicTagName2.symbols | 22 + .../reference/tsxDynamicTagName2.types | 24 + .../reference/tsxDynamicTagName3.symbols | 22 + .../reference/tsxDynamicTagName3.types | 24 + .../reference/tsxDynamicTagName7.symbols | 31 + .../reference/tsxDynamicTagName7.types | 35 + .../reference/tsxElementResolution1.symbols | 23 + .../reference/tsxElementResolution1.types | 25 + .../reference/tsxElementResolution10.symbols | 49 + .../reference/tsxElementResolution10.types | 54 + .../reference/tsxElementResolution11.symbols | 58 + .../reference/tsxElementResolution11.types | 64 + .../reference/tsxElementResolution12.symbols | 91 + .../reference/tsxElementResolution12.types | 104 + .../reference/tsxElementResolution15.symbols | 30 + .../reference/tsxElementResolution15.types | 32 + .../reference/tsxElementResolution16.symbols | 19 + .../reference/tsxElementResolution16.types | 21 + .../reference/tsxElementResolution18.symbols | 13 + .../reference/tsxElementResolution18.types | 14 + .../reference/tsxElementResolution3.symbols | 26 + .../reference/tsxElementResolution3.types | 28 + .../reference/tsxElementResolution4.symbols | 35 + .../reference/tsxElementResolution4.types | 38 + .../reference/tsxElementResolution6.symbols | 19 + .../reference/tsxElementResolution6.types | 20 + .../reference/tsxElementResolution7.symbols | 47 + .../reference/tsxElementResolution7.types | 55 + .../reference/tsxElementResolution8.symbols | 67 + .../reference/tsxElementResolution8.types | 76 + tests/baselines/reference/tsxEmit3.symbols | 51 +- tests/baselines/reference/tsxEmit3.types | 1 - .../reference/tsxErrorRecovery1.symbols | 15 + .../reference/tsxErrorRecovery1.types | 20 + .../reference/tsxErrorRecovery2.symbols | 21 + .../reference/tsxErrorRecovery2.types | 27 + .../reference/tsxErrorRecovery3.symbols | 21 + .../reference/tsxErrorRecovery3.types | 27 + .../tsxGenericAttributesType2.symbols | 24 + .../reference/tsxGenericAttributesType2.types | 28 + .../tsxGenericAttributesType4.symbols | 41 + .../reference/tsxGenericAttributesType4.types | 43 + .../tsxGenericAttributesType5.symbols | 45 + .../reference/tsxGenericAttributesType5.types | 47 + ...ComponentWithDefaultTypeParameter2.symbols | 38 + ...ctComponentWithDefaultTypeParameter2.types | 40 + ...ComponentWithDefaultTypeParameter3.symbols | 45 + ...ctComponentWithDefaultTypeParameter3.types | 49 + .../baselines/reference/tsxReactEmit4.symbols | 36 + tests/baselines/reference/tsxReactEmit4.types | 40 + .../baselines/reference/tsxReactEmit7.symbols | 70 + tests/baselines/reference/tsxReactEmit7.types | 79 + ...SfcReturnUndefinedStrictNullChecks.symbols | 27 + ...sxSfcReturnUndefinedStrictNullChecks.types | 30 + .../tsxSpreadAttributesResolution10.symbols | 63 + .../tsxSpreadAttributesResolution10.types | 73 + .../tsxSpreadAttributesResolution12.symbols | 89 + .../tsxSpreadAttributesResolution12.types | 108 + .../tsxSpreadAttributesResolution14.symbols | 49 + .../tsxSpreadAttributesResolution14.types | 55 + .../tsxSpreadAttributesResolution16.symbols | 54 + .../tsxSpreadAttributesResolution16.types | 60 + .../tsxSpreadAttributesResolution2.symbols | 62 + .../tsxSpreadAttributesResolution2.types | 75 + .../tsxSpreadAttributesResolution5.symbols | 76 + .../tsxSpreadAttributesResolution5.types | 85 + .../tsxSpreadAttributesResolution6.symbols | 43 + .../tsxSpreadAttributesResolution6.types | 50 + .../tsxSpreadChildrenInvalidType.symbols | 104 + .../tsxSpreadChildrenInvalidType.types | 122 + ...tatelessFunctionComponentOverload4.symbols | 158 + ...xStatelessFunctionComponentOverload4.types | 186 + ...tatelessFunctionComponentOverload5.symbols | 178 + ...xStatelessFunctionComponentOverload5.types | 215 + ...ComponentWithDefaultTypeParameter2.symbols | 30 + ...onComponentWithDefaultTypeParameter2.types | 33 + .../tsxStatelessFunctionComponents1.symbols | 148 + .../tsxStatelessFunctionComponents1.types | 184 + .../tsxStatelessFunctionComponents2.symbols | 106 + .../tsxStatelessFunctionComponents2.types | 133 + ...nctionComponentsWithTypeArguments2.symbols | 106 + ...FunctionComponentsWithTypeArguments2.types | 117 + ...nctionComponentsWithTypeArguments4.symbols | 59 + ...FunctionComponentsWithTypeArguments4.types | 61 + ...nctionComponentsWithTypeArguments5.symbols | 81 + ...FunctionComponentsWithTypeArguments5.types | 88 + .../reference/tsxUnionElementType2.symbols | 34 + .../reference/tsxUnionElementType2.types | 39 + .../reference/tsxUnionElementType4.symbols | 91 + .../reference/tsxUnionElementType4.types | 102 + .../reference/tsxUnionElementType6.symbols | 61 + .../reference/tsxUnionElementType6.types | 70 + .../reference/tsxUnionTypeComponent2.symbols | 18 + .../reference/tsxUnionTypeComponent2.types | 20 + tests/baselines/reference/tupleTypes.symbols | 186 + tests/baselines/reference/tupleTypes.types | 241 + .../twoAccessorsWithSameName.symbols | 65 + .../reference/twoAccessorsWithSameName.types | 75 + .../twoAccessorsWithSameName2.symbols | 35 + .../reference/twoAccessorsWithSameName2.types | 38 + ...rfacesDifferingByTypeParameterName.symbols | 140 + ...terfacesDifferingByTypeParameterName.types | 140 + ...facesDifferingByTypeParameterName2.symbols | 103 + ...erfacesDifferingByTypeParameterName2.types | 104 + ...InterfacesWithDifferentConstraints.symbols | 101 + ...icInterfacesWithDifferentConstraints.types | 101 + ...esWithTheSameNameButDifferentArity.symbols | 96 + ...acesWithTheSameNameButDifferentArity.types | 96 + .../twoInterfacesDifferentRootModule.symbols | 70 + .../twoInterfacesDifferentRootModule.types | 74 + .../twoInterfacesDifferentRootModule2.symbols | 98 + .../twoInterfacesDifferentRootModule2.types | 106 + .../typeAliasDeclarationEmit.symbols | 11 +- .../reference/typeAliasDeclarationEmit.types | 1 - .../typeAliasesForObjectTypes.symbols | 35 + .../reference/typeAliasesForObjectTypes.types | 35 + .../reference/typeArgInference2.symbols | 50 + .../reference/typeArgInference2.types | 70 + .../typeArgInference2WithError.symbols | 22 + .../typeArgInference2WithError.types | 25 + .../typeArgumentConstraintResolution1.symbols | 51 + .../typeArgumentConstraintResolution1.types | 56 + .../reference/typeArgumentInference.symbols | 383 + .../reference/typeArgumentInference.types | 511 + ...gumentInferenceConstructSignatures.symbols | 468 + ...ArgumentInferenceConstructSignatures.types | 612 + .../typeArgumentInferenceErrors.symbols | 69 + .../typeArgumentInferenceErrors.types | 84 + ...umentInferenceWithClassExpression2.symbols | 18 + ...rgumentInferenceWithClassExpression2.types | 24 + ...nferenceWithConstraintAsCommonRoot.symbols | 39 + ...tInferenceWithConstraintAsCommonRoot.types | 40 + ...peArgumentInferenceWithConstraints.symbols | 403 + ...typeArgumentInferenceWithConstraints.types | 552 + ...ArgumentInferenceWithObjectLiteral.symbols | 145 + ...peArgumentInferenceWithObjectLiteral.types | 179 + ...ntsOnFunctionsWithNoTypeParameters.symbols | 27 + ...mentsOnFunctionsWithNoTypeParameters.types | 35 + ...sShouldDisallowNonGenericOverloads.symbols | 34 + ...ntsShouldDisallowNonGenericOverloads.types | 43 + ...eArgumentsWithStringLiteralTypes01.symbols | 370 + ...ypeArgumentsWithStringLiteralTypes01.types | 514 + ...typeAssertionToGenericFunctionType.symbols | 29 + .../typeAssertionToGenericFunctionType.types | 38 + .../reference/typeAssertions.symbols | 129 + .../baselines/reference/typeAssertions.types | 175 + ...eAssertionsWithIntersectionTypes01.symbols | 61 + ...ypeAssertionsWithIntersectionTypes01.types | 69 + .../typeAssertionsWithUnionTypes01.symbols | 50 + .../typeAssertionsWithUnionTypes01.types | 57 + .../typeCheckObjectLiteralMethodBody.symbols | 6 + .../typeCheckObjectLiteralMethodBody.types | 7 + .../typeCheckReturnExpression.symbols | 5 + .../reference/typeCheckReturnExpression.types | 6 + .../reference/typeCheckTypeArgument.symbols | 29 + .../reference/typeCheckTypeArgument.types | 37 + ...ingInsideFunctionExpressionInArray.symbols | 15 + ...ckingInsideFunctionExpressionInArray.types | 31 + .../reference/typeComparisonCaching.symbols | 65 + .../reference/typeComparisonCaching.types | 67 + .../reference/typeGuardFunctionErrors.symbols | 427 + .../reference/typeGuardFunctionErrors.types | 484 + .../typeGuardFunctionOfFormThisErrors.symbols | 147 + .../typeGuardFunctionOfFormThisErrors.types | 166 + .../reference/typeGuardInClass.symbols | 29 + .../reference/typeGuardInClass.types | 34 + .../typeGuardOfFormThisMember.symbols | 224 + .../reference/typeGuardOfFormThisMember.types | 254 + .../typeGuardOfFormThisMemberErrors.symbols | 96 + .../typeGuardOfFormThisMemberErrors.types | 105 + ...dOfFormTypeOfEqualEqualHasNoEffect.symbols | 70 + ...ardOfFormTypeOfEqualEqualHasNoEffect.types | 82 + ...ardOfFormTypeOfNotEqualHasNoEffect.symbols | 70 + ...GuardOfFormTypeOfNotEqualHasNoEffect.types | 82 + .../typeGuardOfFormTypeOfOther.symbols | 165 + .../typeGuardOfFormTypeOfOther.types | 200 + .../reference/typeGuardsDefeat.symbols | 82 + .../reference/typeGuardsDefeat.types | 105 + .../reference/typeGuardsInIfStatement.symbols | 295 + .../reference/typeGuardsInIfStatement.types | 398 + .../reference/typeGuardsWithAny.symbols | 61 + .../reference/typeGuardsWithAny.types | 96 + ...thInstanceOfByConstructorSignature.symbols | 505 + ...WithInstanceOfByConstructorSignature.types | 585 + .../typeIdentityConsidersBrands.symbols | 71 + .../typeIdentityConsidersBrands.types | 79 + tests/baselines/reference/typeInfer1.symbols | 33 + tests/baselines/reference/typeInfer1.types | 39 + ...typeInferenceConflictingCandidates.symbols | 19 + .../typeInferenceConflictingCandidates.types | 23 + tests/baselines/reference/typeMatch1.symbols | 81 + tests/baselines/reference/typeMatch1.types | 87 + tests/baselines/reference/typeMatch2.symbols | 163 + tests/baselines/reference/typeMatch2.types | 224 + tests/baselines/reference/typeName1.symbols | 130 + tests/baselines/reference/typeName1.types | 144 + .../typeOfEnumAndVarRedeclarations.symbols | 38 + .../typeOfEnumAndVarRedeclarations.types | 39 + .../reference/typeOfOnTypeArg.symbols | 16 + .../baselines/reference/typeOfOnTypeArg.types | 20 + .../reference/typeOfOperator1.symbols | 12 + .../baselines/reference/typeOfOperator1.types | 15 + tests/baselines/reference/typeOfThis.symbols | 452 + tests/baselines/reference/typeOfThis.types | 503 + .../reference/typeOfThisInAccessor.symbols | 66 + .../reference/typeOfThisInAccessor.types | 73 + .../typeOfThisInConstructorParamList.symbols | 11 + .../typeOfThisInConstructorParamList.types | 11 + .../typeOfThisInInstanceMember.symbols | 110 + .../typeOfThisInInstanceMember.types | 117 + .../typeOfThisInInstanceMember2.symbols | 129 + .../typeOfThisInInstanceMember2.types | 134 + .../typeOfThisInStaticMembers2.symbols | 17 + .../typeOfThisInStaticMembers2.types | 17 + .../reference/typeOfThisInStatics.symbols | 22 + .../reference/typeOfThisInStatics.types | 23 + .../typeParamExtendsOtherTypeParam.symbols | 105 + .../typeParamExtendsOtherTypeParam.types | 105 + .../typeParameterArgumentEquivalence.symbols | 23 + .../typeParameterArgumentEquivalence.types | 25 + .../typeParameterArgumentEquivalence2.symbols | 25 + .../typeParameterArgumentEquivalence2.types | 27 + .../typeParameterArgumentEquivalence3.symbols | 24 + .../typeParameterArgumentEquivalence3.types | 26 + .../typeParameterArgumentEquivalence4.symbols | 25 + .../typeParameterArgumentEquivalence4.types | 27 + .../typeParameterArgumentEquivalence5.symbols | 25 + .../typeParameterArgumentEquivalence5.types | 27 + .../typeParameterAsBaseClass.symbols | 10 + .../reference/typeParameterAsBaseClass.types | 11 + .../reference/typeParameterAsBaseType.symbols | 25 + .../reference/typeParameterAsBaseType.types | 27 + ...arameterAsTypeParameterConstraint2.symbols | 61 + ...eParameterAsTypeParameterConstraint2.types | 81 + .../typeParameterAssignability.symbols | 20 + .../typeParameterAssignability.types | 22 + .../typeParameterAssignability2.symbols | 254 + .../typeParameterAssignability2.types | 300 + .../typeParameterAssignability3.symbols | 86 + .../typeParameterAssignability3.types | 95 + .../typeParameterAssignmentCompat1.symbols | 65 + .../typeParameterAssignmentCompat1.types | 67 + .../typeParameterConstraints1.symbols | 82 + .../reference/typeParameterConstraints1.types | 84 + .../reference/typeParameterDiamond2.symbols | 44 + .../reference/typeParameterDiamond2.types | 47 + .../reference/typeParameterDiamond3.symbols | 44 + .../reference/typeParameterDiamond3.types | 47 + .../reference/typeParameterDiamond4.symbols | 45 + .../reference/typeParameterDiamond4.types | 48 + ...rameterDirectlyConstrainedToItself.symbols | 60 + ...ParameterDirectlyConstrainedToItself.types | 62 + .../typeParameterExplicitlyExtendsAny.symbols | 84 + .../typeParameterExplicitlyExtendsAny.types | 100 + ...xingWithContextSensitiveArguments2.symbols | 49 + ...FixingWithContextSensitiveArguments2.types | 54 + ...xingWithContextSensitiveArguments3.symbols | 52 + ...FixingWithContextSensitiveArguments3.types | 57 + .../typeParameterHasSelfAsConstraint.symbols | 13 + .../typeParameterHasSelfAsConstraint.types | 13 + ...meterIndirectlyConstrainedToItself.symbols | 92 + ...rameterIndirectlyConstrainedToItself.types | 94 + ...eterUsedAsTypeParameterConstraint4.symbols | 215 + ...ameterUsedAsTypeParameterConstraint4.types | 233 + ...ParameterWithInvalidConstraintType.symbols | 30 + ...peParameterWithInvalidConstraintType.types | 38 + ...metersAndParametersInComputedNames.symbols | 20 + ...rametersAndParametersInComputedNames.types | 24 + .../typeParametersInStaticAccessors.symbols | 13 + .../typeParametersInStaticAccessors.types | 16 + .../typeParametersInStaticMethods.symbols | 13 + .../typeParametersInStaticMethods.types | 15 + .../typeParametersInStaticProperties.symbols | 8 + .../typeParametersInStaticProperties.types | 9 + .../typeParametersShouldNotBeEqual.symbols | 31 + .../typeParametersShouldNotBeEqual.types | 35 + .../typeParametersShouldNotBeEqual2.symbols | 52 + .../typeParametersShouldNotBeEqual2.types | 60 + .../typeParametersShouldNotBeEqual3.symbols | 33 + .../typeParametersShouldNotBeEqual3.types | 37 + ...pePredicateOnVariableDeclaration01.symbols | 4 + ...typePredicateOnVariableDeclaration01.types | 4 + ...pePredicateOnVariableDeclaration02.symbols | 5 + ...typePredicateOnVariableDeclaration02.types | 7 + .../reference/typeQueryOnClass.symbols | 123 + .../reference/typeQueryOnClass.types | 133 + .../typeReferenceDirectives11.symbols | 14 +- .../reference/typeReferenceDirectives11.types | 6 +- .../typeReferenceDirectives12.symbols | 4 +- .../reference/typeReferenceDirectives12.types | 2 - .../reference/typeRelationships.symbols | 186 + .../reference/typeRelationships.types | 205 + .../reference/typeUsedAsValueError.symbols | 50 + .../reference/typeUsedAsValueError.types | 62 + .../reference/typeUsedAsValueError2.symbols | 31 + .../reference/typeUsedAsValueError2.types | 39 + .../reference/typeValueConflict1.symbols | 23 + .../reference/typeValueConflict1.types | 24 + .../reference/typeValueConflict2.symbols | 40 + .../reference/typeValueConflict2.types | 41 + .../typecheckCommaExpression.symbols | 3 + .../reference/typecheckCommaExpression.types | 7 + .../reference/typecheckIfCondition.symbols | 10 + .../reference/typecheckIfCondition.types | 21 + .../typedArraysCrossAssignability01.symbols | 330 + .../typedArraysCrossAssignability01.types | 420 + .../reference/typeofANonExportedType.symbols | 141 + .../reference/typeofANonExportedType.types | 146 + .../typeofAmbientExternalModules.symbols | 40 + .../typeofAmbientExternalModules.types | 42 + .../reference/typeofAnExportedType.symbols | 141 + .../reference/typeofAnExportedType.types | 146 + tests/baselines/reference/typeofClass.symbols | 35 + tests/baselines/reference/typeofClass.types | 39 + .../reference/typeofClassWithPrivates.symbols | 31 + .../reference/typeofClassWithPrivates.types | 32 + .../reference/typeofExternalModules.symbols | 36 + .../reference/typeofExternalModules.types | 38 + .../typeofInObjectLiteralType.symbols | 6 + .../reference/typeofInObjectLiteralType.types | 7 + .../reference/typeofInternalModules.symbols | 76 + .../reference/typeofInternalModules.types | 85 + .../typeofOperatorInvalidOperations.symbols | 12 + .../typeofOperatorInvalidOperations.types | 16 + .../typeofOperatorWithAnyOtherType.symbols | 222 + .../typeofOperatorWithAnyOtherType.types | 297 + .../typeofOperatorWithBooleanType.symbols | 119 +- .../typeofOperatorWithBooleanType.types | 59 +- .../typeofOperatorWithEnumType.symbols | 47 +- .../typeofOperatorWithEnumType.types | 43 +- .../typeofOperatorWithNumberType.types | 86 +- .../typeofOperatorWithStringType.symbols | 167 + .../typeofOperatorWithStringType.types | 233 + .../reference/typeofProperty.symbols | 95 + .../baselines/reference/typeofProperty.types | 102 + .../baselines/reference/typeofSimple.symbols | 37 + tests/baselines/reference/typeofSimple.types | 41 + .../reference/typeofTypeParameter.symbols | 18 + .../reference/typeofTypeParameter.types | 19 + .../reference/typeofUnknownSymbol.symbols | 5 + .../reference/typeofUnknownSymbol.types | 7 + .../types.asyncGenerators.esnext.2.symbols | 151 + .../types.asyncGenerators.esnext.2.types | 258 + .../reference/types.forAwait.esnext.2.symbols | 41 + .../reference/types.forAwait.esnext.2.types | 43 + .../reference/types.forAwait.esnext.3.symbols | 27 + .../reference/types.forAwait.esnext.3.types | 31 + ...OnlyExternalModuleStillHasInstance.symbols | 39 + ...esOnlyExternalModuleStillHasInstance.types | 40 + .../typesWithDuplicateTypeParameters.symbols | 34 + .../typesWithDuplicateTypeParameters.types | 34 + .../typesWithPrivateConstructor.symbols | 34 + .../typesWithPrivateConstructor.types | 40 + .../typesWithProtectedConstructor.symbols | 34 + .../typesWithProtectedConstructor.types | 40 + .../typesWithPublicConstructor.symbols | 38 + .../typesWithPublicConstructor.types | 42 + tests/baselines/reference/umd-errors.symbols | 43 + tests/baselines/reference/umd-errors.types | 47 + tests/baselines/reference/umd2.symbols | 9 + tests/baselines/reference/umd2.types | 18 + tests/baselines/reference/umd5.symbols | 40 + tests/baselines/reference/umd5.types | 41 + tests/baselines/reference/umd8.symbols | 38 +- tests/baselines/reference/umd8.types | 26 +- .../reference/umdDependencyComment2.symbols | 9 + .../reference/umdDependencyComment2.types | 12 + .../umdDependencyCommentName1.symbols | 9 + .../reference/umdDependencyCommentName1.types | 12 + .../umdDependencyCommentName2.symbols | 11 + .../reference/umdDependencyCommentName2.types | 14 + .../reference/unaryOperators1.symbols | 5 + .../baselines/reference/unaryOperators1.types | 13 + .../unaryOperatorsInStrictMode.symbols | 20 + .../unaryOperatorsInStrictMode.types | 36 + .../reference/uncaughtCompilerError2.symbols | 7 + .../reference/uncaughtCompilerError2.types | 12 + .../reference/unclosedExportClause01.symbols | 25 + .../reference/unclosedExportClause01.types | 26 + .../reference/unclosedExportClause02.symbols | 32 + .../reference/unclosedExportClause02.types | 38 + .../reference/undeclaredBase.symbols | 7 + .../baselines/reference/undeclaredBase.types | 9 + .../reference/undeclaredMethod.symbols | 29 + .../reference/undeclaredMethod.types | 34 + .../reference/undeclaredModuleError.symbols | 58 + .../reference/undeclaredModuleError.types | 69 + .../reference/undeclaredVarEmit.symbols | 3 + .../reference/undeclaredVarEmit.types | 5 + ...nedSymbolReferencedInArrayLiteral1.symbols | 13 + ...finedSymbolReferencedInArrayLiteral1.types | 29 + .../reference/undefinedTypeArgument1.symbols | 5 + .../reference/undefinedTypeArgument1.types | 7 + .../reference/undefinedTypeArgument2.symbols | 30 + .../reference/undefinedTypeArgument2.types | 32 + .../undefinedTypeAssignment1.symbols | 12 + .../reference/undefinedTypeAssignment1.types | 13 + .../undefinedTypeAssignment2.symbols | 4 + .../reference/undefinedTypeAssignment2.types | 6 + .../undefinedTypeAssignment3.symbols | 4 + .../reference/undefinedTypeAssignment3.types | 5 + .../undefinedTypeAssignment4.symbols | 26 + .../reference/undefinedTypeAssignment4.types | 27 + .../baselines/reference/underscoreTest1.types | 8 +- .../underscoreThisInDerivedClass01.types | 2 +- .../underscoreThisInDerivedClass02.symbols | 24 + .../underscoreThisInDerivedClass02.types | 26 + ...unexpectedStatementBlockTerminator.symbols | 14 + .../unexpectedStatementBlockTerminator.types | 17 + ...codeExtendedEscapesInStrings07_ES5.symbols | 6 + ...nicodeExtendedEscapesInStrings07_ES5.types | 7 + ...codeExtendedEscapesInStrings07_ES6.symbols | 6 + ...nicodeExtendedEscapesInStrings07_ES6.types | 7 + ...codeExtendedEscapesInStrings12_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings12_ES5.types | 5 + ...codeExtendedEscapesInStrings12_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings12_ES6.types | 5 + ...codeExtendedEscapesInStrings14_ES5.symbols | 5 + ...nicodeExtendedEscapesInStrings14_ES5.types | 6 + ...codeExtendedEscapesInStrings14_ES6.symbols | 5 + ...nicodeExtendedEscapesInStrings14_ES6.types | 6 + ...codeExtendedEscapesInStrings17_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings17_ES5.types | 5 + ...codeExtendedEscapesInStrings17_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings17_ES6.types | 5 + ...codeExtendedEscapesInStrings19_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings19_ES5.types | 5 + ...codeExtendedEscapesInStrings19_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings19_ES6.types | 5 + ...codeExtendedEscapesInStrings20_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings20_ES5.types | 5 + ...codeExtendedEscapesInStrings20_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings20_ES6.types | 5 + ...codeExtendedEscapesInStrings21_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings21_ES5.types | 5 + ...codeExtendedEscapesInStrings21_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings21_ES6.types | 5 + ...codeExtendedEscapesInStrings22_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings22_ES5.types | 5 + ...codeExtendedEscapesInStrings22_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings22_ES6.types | 5 + ...codeExtendedEscapesInStrings24_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings24_ES5.types | 5 + ...codeExtendedEscapesInStrings24_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings24_ES6.types | 5 + ...codeExtendedEscapesInStrings25_ES5.symbols | 4 + ...nicodeExtendedEscapesInStrings25_ES5.types | 5 + ...codeExtendedEscapesInStrings25_ES6.symbols | 4 + ...nicodeExtendedEscapesInStrings25_ES6.types | 5 + ...deExtendedEscapesInTemplates07_ES5.symbols | 6 + ...codeExtendedEscapesInTemplates07_ES5.types | 7 + ...deExtendedEscapesInTemplates07_ES6.symbols | 6 + ...codeExtendedEscapesInTemplates07_ES6.types | 7 + ...deExtendedEscapesInTemplates12_ES5.symbols | 4 + ...codeExtendedEscapesInTemplates12_ES5.types | 5 + ...deExtendedEscapesInTemplates12_ES6.symbols | 4 + ...codeExtendedEscapesInTemplates12_ES6.types | 5 + ...deExtendedEscapesInTemplates14_ES5.symbols | 5 + ...codeExtendedEscapesInTemplates14_ES5.types | 6 + ...deExtendedEscapesInTemplates14_ES6.symbols | 5 + ...codeExtendedEscapesInTemplates14_ES6.types | 6 + ...deExtendedEscapesInTemplates17_ES5.symbols | 4 + ...codeExtendedEscapesInTemplates17_ES5.types | 5 + ...deExtendedEscapesInTemplates17_ES6.symbols | 4 + ...codeExtendedEscapesInTemplates17_ES6.types | 5 + ...deExtendedEscapesInTemplates19_ES5.symbols | 4 + ...codeExtendedEscapesInTemplates19_ES5.types | 5 + ...deExtendedEscapesInTemplates19_ES6.symbols | 4 + ...codeExtendedEscapesInTemplates19_ES6.types | 5 + .../reference/unicodeIdentifierName2.symbols | 5 + .../reference/unicodeIdentifierName2.types | 8 + .../reference/unionPropertyExistence.symbols | 101 + .../reference/unionPropertyExistence.types | 118 + ...ypeIfEveryConstituentTypeIsSubtype.symbols | 340 + ...btypeIfEveryConstituentTypeIsSubtype.types | 342 + .../reference/unionTypeCallSignatures.symbols | 260 + .../reference/unionTypeCallSignatures.types | 393 + .../unionTypeCallSignatures4.symbols | 89 + .../reference/unionTypeCallSignatures4.types | 125 + .../unionTypeConstructSignatures.symbols | 246 + .../unionTypeConstructSignatures.types | 372 + .../reference/unionTypeEquivalence.symbols | 50 + .../reference/unionTypeEquivalence.types | 50 + .../reference/unionTypeIdentity.symbols | 21 + .../reference/unionTypeIdentity.types | 21 + .../reference/unionTypeInference.types | 8 +- .../reference/unionTypeLiterals.symbols | 34 + .../reference/unionTypeLiterals.types | 34 + .../reference/unionTypeMembers.symbols | 182 + .../reference/unionTypeMembers.types | 209 + .../unionTypePropertyAccessibility.symbols | 161 + .../unionTypePropertyAccessibility.types | 181 + .../reference/unionTypeReadonly.symbols | 79 + .../reference/unionTypeReadonly.types | 91 + ...TypeWithRecursiveSubtypeReduction2.symbols | 51 + ...onTypeWithRecursiveSubtypeReduction2.types | 53 + ...TypeWithRecursiveSubtypeReduction3.symbols | 19 + ...onTypeWithRecursiveSubtypeReduction3.types | 19 + .../reference/unionTypesAssignability.symbols | 242 + .../reference/unionTypesAssignability.types | 289 + .../unknownSymbolInGenericReturnType.symbols | 42 + .../unknownSymbolInGenericReturnType.types | 51 + .../unknownSymbolOffContextualType1.symbols | 80 + .../unknownSymbolOffContextualType1.types | 94 + .../reference/unknownSymbols1.symbols | 65 + .../baselines/reference/unknownSymbols1.types | 85 + .../reference/unknownSymbols2.symbols | 53 + .../baselines/reference/unknownSymbols2.types | 70 + .../reference/unknownTypeArgOnCall.symbols | 22 + .../reference/unknownTypeArgOnCall.types | 26 + .../reference/unknownTypeErrors.symbols | 4 + .../reference/unknownTypeErrors.types | 6 + .../unqualifiedCallToClassStatic1.symbols | 11 + .../unqualifiedCallToClassStatic1.types | 14 + .../unreachableJavascriptChecked.symbols | 7 + .../unreachableJavascriptChecked.types | 10 + .../unresolvedTypeAssertionSymbol.symbols | 9 + .../unresolvedTypeAssertionSymbol.types | 12 + .../unspecializedConstraints.symbols | 551 + .../reference/unspecializedConstraints.types | 652 + .../unterminatedRegexAtEndOfSource1.symbols | 4 + .../unterminatedRegexAtEndOfSource1.types | 5 + ...minatedStringLiteralWithBackslash1.symbols | 3 + ...erminatedStringLiteralWithBackslash1.types | 4 + ...edFunctionCallsWithTypeParameters1.symbols | 111 + ...ypedFunctionCallsWithTypeParameters1.types | 127 + .../untypedModuleImport_noImplicitAny.symbols | 4 + .../untypedModuleImport_noImplicitAny.types | 4 + ...typedModuleImport_withAugmentation.symbols | 11 + ...untypedModuleImport_withAugmentation.types | 11 + ...ypedModuleImport_withAugmentation2.symbols | 12 + ...ntypedModuleImport_withAugmentation2.types | 12 + .../reference/unusedClassesinModule1.symbols | 12 + .../reference/unusedClassesinModule1.types | 12 + .../unusedClassesinNamespace1.symbols | 9 + .../reference/unusedClassesinNamespace1.types | 9 + .../unusedClassesinNamespace2.symbols | 14 + .../reference/unusedClassesinNamespace2.types | 14 + .../unusedClassesinNamespace4.symbols | 20 + .../reference/unusedClassesinNamespace4.types | 20 + .../unusedClassesinNamespace5.symbols | 22 + .../reference/unusedClassesinNamespace5.types | 22 + .../unusedDestructuringParameters.symbols | 23 + .../unusedDestructuringParameters.types | 35 + .../unusedFunctionsinNamespaces1.symbols | 8 + .../unusedFunctionsinNamespaces1.types | 8 + .../unusedFunctionsinNamespaces2.symbols | 8 + .../unusedFunctionsinNamespaces2.types | 9 + .../unusedFunctionsinNamespaces3.symbols | 9 + .../unusedFunctionsinNamespaces3.types | 10 + .../unusedFunctionsinNamespaces4.symbols | 13 + .../unusedFunctionsinNamespaces4.types | 14 + .../unusedFunctionsinNamespaces5.symbols | 25 + .../unusedFunctionsinNamespaces5.types | 27 + .../unusedFunctionsinNamespaces6.symbols | 29 + .../unusedFunctionsinNamespaces6.types | 31 + .../unusedIdentifiersConsolidated1.symbols | 191 + .../unusedIdentifiersConsolidated1.types | 204 + .../reference/unusedImports1.symbols | 10 + .../baselines/reference/unusedImports1.types | 10 + .../reference/unusedImports10.symbols | 20 + .../baselines/reference/unusedImports10.types | 20 + .../reference/unusedImports12.symbols | 23 + .../baselines/reference/unusedImports12.types | 23 + .../reference/unusedImports2.symbols | 29 + .../baselines/reference/unusedImports2.types | 31 + .../reference/unusedImports3.symbols | 30 + .../baselines/reference/unusedImports3.types | 32 + .../reference/unusedImports4.symbols | 36 + .../baselines/reference/unusedImports4.types | 39 + .../reference/unusedImports5.symbols | 36 + .../baselines/reference/unusedImports5.types | 39 + .../reference/unusedImports6.symbols | 25 + .../baselines/reference/unusedImports6.types | 25 + .../reference/unusedImports7.symbols | 23 + .../baselines/reference/unusedImports7.types | 23 + .../reference/unusedImports8.symbols | 39 + .../baselines/reference/unusedImports8.types | 42 + .../reference/unusedImports9.symbols | 22 + .../baselines/reference/unusedImports9.types | 22 + .../unusedInterfaceinNamespace1.symbols | 9 + .../unusedInterfaceinNamespace1.types | 9 + .../unusedInterfaceinNamespace2.symbols | 14 + .../unusedInterfaceinNamespace2.types | 14 + .../unusedInterfaceinNamespace3.symbols | 20 + .../unusedInterfaceinNamespace3.types | 20 + .../unusedInvalidTypeArguments.symbols | 98 + .../unusedInvalidTypeArguments.types | 113 + .../unusedLocalsAndObjectSpread.symbols | 84 + .../unusedLocalsAndObjectSpread.types | 98 + .../unusedLocalsAndObjectSpread2.symbols | 37 + .../unusedLocalsAndObjectSpread2.types | 40 + .../unusedLocalsAndParameters.symbols | 134 + .../reference/unusedLocalsAndParameters.types | 155 + .../unusedLocalsAndParametersDeferred.symbols | 319 + .../unusedLocalsAndParametersDeferred.types | 385 + ...sedLocalsAndParametersTypeAliases2.symbols | 17 + ...nusedLocalsAndParametersTypeAliases2.types | 18 + .../reference/unusedLocalsInMethod1.symbols | 11 + .../reference/unusedLocalsInMethod1.types | 12 + .../reference/unusedLocalsInMethod2.symbols | 15 + .../reference/unusedLocalsInMethod2.types | 17 + .../reference/unusedLocalsInMethod3.symbols | 15 + .../reference/unusedLocalsInMethod3.types | 17 + ...larationWithinFunctionDeclaration1.symbols | 19 + ...eclarationWithinFunctionDeclaration1.types | 23 + ...larationWithinFunctionDeclaration2.symbols | 27 + ...eclarationWithinFunctionDeclaration2.types | 31 + ...clarationWithinFunctionExpression1.symbols | 19 + ...DeclarationWithinFunctionExpression1.types | 24 + ...clarationWithinFunctionExpression2.symbols | 27 + ...DeclarationWithinFunctionExpression2.types | 32 + ...pressionWithinFunctionDeclaration1.symbols | 19 + ...ExpressionWithinFunctionDeclaration1.types | 24 + ...pressionWithinFunctionDeclaration2.symbols | 27 + ...ExpressionWithinFunctionDeclaration2.types | 33 + ...xpressionWithinFunctionExpression1.symbols | 19 + ...nExpressionWithinFunctionExpression1.types | 25 + ...xpressionWithinFunctionExpression2.symbols | 27 + ...nExpressionWithinFunctionExpression2.types | 34 + ...unusedLocalsStartingWithUnderscore.symbols | 20 + .../unusedLocalsStartingWithUnderscore.types | 24 + .../unusedLocalsinConstructor1.symbols | 9 + .../unusedLocalsinConstructor1.types | 10 + .../unusedLocalsinConstructor2.symbols | 16 + .../unusedLocalsinConstructor2.types | 21 + .../reference/unusedModuleInModule.symbols | 7 + .../reference/unusedModuleInModule.types | 7 + ...usedMultipleParameter1InContructor.symbols | 15 + ...unusedMultipleParameter1InContructor.types | 18 + ...ipleParameter1InFunctionExpression.symbols | 12 + ...ltipleParameter1InFunctionExpression.types | 16 + ...usedMultipleParameter2InContructor.symbols | 16 + ...unusedMultipleParameter2InContructor.types | 19 + ...ipleParameter2InFunctionExpression.symbols | 13 + ...ltipleParameter2InFunctionExpression.types | 17 + ...leParameters1InFunctionDeclaration.symbols | 12 + ...ipleParameters1InFunctionDeclaration.types | 15 + ...ipleParameters1InMethodDeclaration.symbols | 16 + ...ltipleParameters1InMethodDeclaration.types | 19 + ...leParameters2InFunctionDeclaration.symbols | 13 + ...ipleParameters2InFunctionDeclaration.types | 16 + ...ipleParameters2InMethodDeclaration.symbols | 17 + ...ltipleParameters2InMethodDeclaration.types | 20 + .../reference/unusedNamespaceInModule.symbols | 10 + .../reference/unusedNamespaceInModule.types | 10 + .../unusedNamespaceInNamespace.symbols | 10 + .../unusedNamespaceInNamespace.types | 10 + .../unusedParameterProperty1.symbols | 16 + .../reference/unusedParameterProperty1.types | 18 + .../unusedParameterProperty2.symbols | 16 + .../reference/unusedParameterProperty2.types | 18 + .../unusedParametersInLambda1.symbols | 12 + .../reference/unusedParametersInLambda1.types | 13 + .../unusedParametersInLambda2.symbols | 16 + .../reference/unusedParametersInLambda2.types | 17 + .../unusedParametersWithUnderscore.symbols | 50 + .../unusedParametersWithUnderscore.types | 53 + .../unusedParametersinConstructor1.symbols | 8 + .../unusedParametersinConstructor1.types | 8 + .../unusedParametersinConstructor2.symbols | 13 + .../unusedParametersinConstructor2.types | 16 + .../unusedParametersinConstructor3.symbols | 14 + .../unusedParametersinConstructor3.types | 17 + .../unusedPrivateMethodInClass1.symbols | 14 + .../unusedPrivateMethodInClass1.types | 16 + .../unusedPrivateMethodInClass2.symbols | 24 + .../unusedPrivateMethodInClass2.types | 28 + .../unusedPrivateMethodInClass3.symbols | 34 + .../unusedPrivateMethodInClass3.types | 40 + .../unusedPrivateMethodInClass4.symbols | 39 + .../unusedPrivateMethodInClass4.types | 46 + .../unusedPrivateVariableInClass1.symbols | 7 + .../unusedPrivateVariableInClass1.types | 7 + .../unusedPrivateVariableInClass2.symbols | 10 + .../unusedPrivateVariableInClass2.types | 10 + .../unusedPrivateVariableInClass3.symbols | 13 + .../unusedPrivateVariableInClass3.types | 13 + .../unusedPrivateVariableInClass4.symbols | 22 + .../unusedPrivateVariableInClass4.types | 22 + .../unusedPrivateVariableInClass5.symbols | 20 + .../unusedPrivateVariableInClass5.types | 20 + .../unusedSingleParameterInContructor.symbols | 11 + .../unusedSingleParameterInContructor.types | 12 + ...ngleParameterInFunctionDeclaration.symbols | 8 + ...SingleParameterInFunctionDeclaration.types | 9 + ...ingleParameterInFunctionExpression.symbols | 8 + ...dSingleParameterInFunctionExpression.types | 10 + ...SingleParameterInMethodDeclaration.symbols | 12 + ...edSingleParameterInMethodDeclaration.types | 13 + .../reference/unusedSwitchStatment.symbols | 27 + .../reference/unusedSwitchStatment.types | 42 + .../unusedTypeParameterInFunction1.symbols | 6 + .../unusedTypeParameterInFunction1.types | 6 + .../unusedTypeParameterInFunction2.symbols | 13 + .../unusedTypeParameterInFunction2.types | 13 + .../unusedTypeParameterInFunction3.symbols | 21 + .../unusedTypeParameterInFunction3.types | 21 + .../unusedTypeParameterInFunction4.symbols | 21 + .../unusedTypeParameterInFunction4.types | 21 + .../unusedTypeParameterInInterface1.symbols | 6 + .../unusedTypeParameterInInterface1.types | 6 + .../unusedTypeParameterInInterface2.symbols | 16 + .../unusedTypeParameterInInterface2.types | 16 + .../unusedTypeParameterInLambda1.symbols | 13 + .../unusedTypeParameterInLambda1.types | 14 + .../unusedTypeParameterInLambda2.symbols | 20 + .../unusedTypeParameterInLambda2.types | 21 + .../unusedTypeParameterInLambda3.symbols | 17 + .../unusedTypeParameterInLambda3.types | 17 + .../unusedTypeParameterInMethod1.symbols | 25 + .../unusedTypeParameterInMethod1.types | 25 + .../unusedTypeParameterInMethod2.symbols | 25 + .../unusedTypeParameterInMethod2.types | 25 + .../unusedTypeParameterInMethod3.symbols | 25 + .../unusedTypeParameterInMethod3.types | 25 + .../unusedTypeParameterInMethod4.symbols | 10 + .../unusedTypeParameterInMethod4.types | 10 + .../unusedTypeParameterInMethod5.symbols | 10 + .../unusedTypeParameterInMethod5.types | 11 + .../reference/unusedTypeParameters1.symbols | 6 + .../reference/unusedTypeParameters1.types | 6 + .../reference/unusedTypeParameters10.symbols | 11 + .../reference/unusedTypeParameters10.types | 11 + .../reference/unusedTypeParameters2.symbols | 19 + .../reference/unusedTypeParameters2.types | 19 + .../reference/unusedTypeParameters3.symbols | 20 + .../reference/unusedTypeParameters3.types | 20 + .../reference/unusedTypeParameters4.symbols | 10 + .../reference/unusedTypeParameters4.types | 10 + .../reference/unusedTypeParameters5.symbols | 22 + .../reference/unusedTypeParameters5.types | 22 + .../reference/unusedTypeParameters8.symbols | 10 + .../reference/unusedTypeParameters8.types | 10 + ...unusedTypeParametersWithUnderscore.symbols | 21 + .../unusedTypeParametersWithUnderscore.types | 21 + .../unusedVariablesinBlocks1.symbols | 14 + .../reference/unusedVariablesinBlocks1.types | 17 + .../unusedVariablesinBlocks2.symbols | 13 + .../reference/unusedVariablesinBlocks2.types | 16 + .../unusedVariablesinForLoop.symbols | 9 + .../reference/unusedVariablesinForLoop.types | 10 + .../unusedVariablesinForLoop2.symbols | 9 + .../reference/unusedVariablesinForLoop2.types | 13 + .../unusedVariablesinForLoop3.symbols | 9 + .../reference/unusedVariablesinForLoop3.types | 13 + .../unusedVariablesinForLoop4.symbols | 14 + .../reference/unusedVariablesinForLoop4.types | 19 + .../unusedVariablesinModules1.symbols | 9 + .../reference/unusedVariablesinModules1.types | 9 + .../unusedVariablesinNamespaces1.symbols | 7 + .../unusedVariablesinNamespaces1.types | 8 + .../unusedVariablesinNamespaces2.symbols | 25 + .../unusedVariablesinNamespaces2.types | 28 + .../unusedVariablesinNamespaces3.symbols | 28 + .../unusedVariablesinNamespaces3.types | 32 + ...foreDeclaration_propertyAssignment.symbols | 15 + ...BeforeDeclaration_propertyAssignment.types | 17 + .../useBeforeDeclaration_superClass.symbols | 68 + .../useBeforeDeclaration_superClass.types | 73 + .../useObjectValuesAndEntries2.symbols | 21 + .../useObjectValuesAndEntries2.types | 30 + .../useObjectValuesAndEntries3.symbols | 21 + .../useObjectValuesAndEntries3.types | 30 + .../reference/useSharedArrayBuffer2.symbols | 12 + .../reference/useSharedArrayBuffer2.types | 22 + .../reference/useSharedArrayBuffer3.symbols | 12 + .../reference/useSharedArrayBuffer3.types | 22 + .../validMultipleVariableDeclarations.symbols | 118 + .../validMultipleVariableDeclarations.types | 152 + .../reference/validNullAssignments.symbols | 79 + .../reference/validNullAssignments.types | 105 + tests/baselines/reference/validRegexp.symbols | 11 + tests/baselines/reference/validRegexp.types | 14 + .../reference/varAndFunctionShareName.symbols | 7 + .../reference/varAndFunctionShareName.types | 7 + .../varArgConstructorMemberParameter.symbols | 22 + .../varArgConstructorMemberParameter.types | 22 + .../reference/varArgWithNoParamName.symbols | 5 + .../reference/varArgWithNoParamName.types | 5 + tests/baselines/reference/varBlock.symbols | 93 + tests/baselines/reference/varBlock.types | 112 + ...sWithImportInDifferentPartOfModule.symbols | 18 + ...ctsWithImportInDifferentPartOfModule.types | 20 + tests/baselines/reference/vararg.symbols | 127 + tests/baselines/reference/vararg.types | 185 + .../variableDeclarationInStrictMode1.symbols | 5 + .../variableDeclarationInStrictMode1.types | 7 + ...atorResolvedDuringContextualTyping.symbols | 442 + ...aratorResolvedDuringContextualTyping.types | 465 + .../baselines/reference/voidArrayLit.symbols | 12 + tests/baselines/reference/voidArrayLit.types | 24 + .../voidAsNonAmbiguousReturnType.symbols | 25 + .../voidAsNonAmbiguousReturnType.types | 27 + .../voidOperatorInvalidOperations.symbols | 12 + .../voidOperatorInvalidOperations.types | 16 + .../voidOperatorWithAnyOtherType.symbols | 178 + .../voidOperatorWithAnyOtherType.types | 236 + tests/baselines/reference/weakType.symbols | 163 + tests/baselines/reference/weakType.types | 184 + .../reference/whileContinueStatements.symbols | 56 + .../reference/whileContinueStatements.types | 110 + tests/baselines/reference/widenToAny1.symbols | 21 + tests/baselines/reference/widenToAny1.types | 24 + tests/baselines/reference/widenToAny2.symbols | 16 + tests/baselines/reference/widenToAny2.types | 19 + .../baselines/reference/widenedTypes.symbols | 49 + tests/baselines/reference/widenedTypes.types | 96 + .../reference/wideningTuples3.symbols | 9 + .../baselines/reference/wideningTuples3.types | 12 + .../reference/wideningTuples5.symbols | 6 + .../baselines/reference/wideningTuples5.types | 8 + .../reference/wideningTuples7.symbols | 13 + .../baselines/reference/wideningTuples7.types | 16 + .../baselines/reference/withStatement.symbols | 16 + tests/baselines/reference/withStatement.types | 40 + .../reference/withStatementErrors.symbols | 22 + .../reference/withStatementErrors.types | 49 + .../withStatementNestedScope.symbols | 13 + .../reference/withStatementNestedScope.types | 22 + .../reference/withStatements.symbols | 10 + .../baselines/reference/withStatements.types | 18 + tests/baselines/reference/witness.symbols | 352 + tests/baselines/reference/witness.types | 411 + .../wrappedAndRecursiveConstraints4.symbols | 50 + .../wrappedAndRecursiveConstraints4.types | 60 + .../wrappedRecursiveGenericType.symbols | 70 + .../wrappedRecursiveGenericType.types | 78 + .../reference/yieldStringLiteral.symbols | 7 + .../reference/yieldStringLiteral.types | 9 + 8086 files changed, 672804 insertions(+), 2181 deletions(-) create mode 100644 tests/baselines/reference/ArrowFunction1.symbols create mode 100644 tests/baselines/reference/ArrowFunction1.types create mode 100644 tests/baselines/reference/ArrowFunction3.symbols create mode 100644 tests/baselines/reference/ArrowFunction3.types create mode 100644 tests/baselines/reference/ArrowFunctionExpression1.symbols create mode 100644 tests/baselines/reference/ArrowFunctionExpression1.types create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.symbols create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.types create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.symbols create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.types create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.symbols create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.types create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.symbols create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.symbols create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.symbols create mode 100644 tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.types create mode 100644 tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.symbols create mode 100644 tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.types create mode 100644 tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.symbols create mode 100644 tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.types create mode 100644 tests/baselines/reference/ClassDeclaration10.symbols create mode 100644 tests/baselines/reference/ClassDeclaration10.types create mode 100644 tests/baselines/reference/ClassDeclaration11.symbols create mode 100644 tests/baselines/reference/ClassDeclaration11.types create mode 100644 tests/baselines/reference/ClassDeclaration13.symbols create mode 100644 tests/baselines/reference/ClassDeclaration13.types create mode 100644 tests/baselines/reference/ClassDeclaration14.symbols create mode 100644 tests/baselines/reference/ClassDeclaration14.types create mode 100644 tests/baselines/reference/ClassDeclaration15.symbols create mode 100644 tests/baselines/reference/ClassDeclaration15.types create mode 100644 tests/baselines/reference/ClassDeclaration21.symbols create mode 100644 tests/baselines/reference/ClassDeclaration21.types create mode 100644 tests/baselines/reference/ClassDeclaration22.symbols create mode 100644 tests/baselines/reference/ClassDeclaration22.types create mode 100644 tests/baselines/reference/ClassDeclaration24.symbols create mode 100644 tests/baselines/reference/ClassDeclaration24.types create mode 100644 tests/baselines/reference/ClassDeclaration25.symbols create mode 100644 tests/baselines/reference/ClassDeclaration25.types create mode 100644 tests/baselines/reference/ClassDeclaration26.symbols create mode 100644 tests/baselines/reference/ClassDeclaration26.types create mode 100644 tests/baselines/reference/ClassDeclaration8.symbols create mode 100644 tests/baselines/reference/ClassDeclaration8.types create mode 100644 tests/baselines/reference/ClassDeclaration9.symbols create mode 100644 tests/baselines/reference/ClassDeclaration9.types create mode 100644 tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.symbols create mode 100644 tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.types create mode 100644 tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols create mode 100644 tests/baselines/reference/DeclarationErrorsNoEmitOnError.types create mode 100644 tests/baselines/reference/ES3For-ofTypeCheck1.symbols create mode 100644 tests/baselines/reference/ES3For-ofTypeCheck1.types create mode 100644 tests/baselines/reference/ES3For-ofTypeCheck4.symbols create mode 100644 tests/baselines/reference/ES3For-ofTypeCheck4.types create mode 100644 tests/baselines/reference/ES5For-of1.symbols create mode 100644 tests/baselines/reference/ES5For-of1.types create mode 100644 tests/baselines/reference/ES5For-of12.symbols create mode 100644 tests/baselines/reference/ES5For-of12.types create mode 100644 tests/baselines/reference/ES5For-of17.symbols create mode 100644 tests/baselines/reference/ES5For-of17.types create mode 100644 tests/baselines/reference/ES5For-of20.symbols create mode 100644 tests/baselines/reference/ES5For-of20.types create mode 100644 tests/baselines/reference/ES5For-of22.symbols create mode 100644 tests/baselines/reference/ES5For-of22.types create mode 100644 tests/baselines/reference/ES5For-of23.symbols create mode 100644 tests/baselines/reference/ES5For-of23.types create mode 100644 tests/baselines/reference/ES5For-of26.symbols create mode 100644 tests/baselines/reference/ES5For-of26.types create mode 100644 tests/baselines/reference/ES5For-of27.symbols create mode 100644 tests/baselines/reference/ES5For-of27.types create mode 100644 tests/baselines/reference/ES5For-of28.symbols create mode 100644 tests/baselines/reference/ES5For-of28.types create mode 100644 tests/baselines/reference/ES5For-of29.symbols create mode 100644 tests/baselines/reference/ES5For-of29.types create mode 100644 tests/baselines/reference/ES5For-of30.symbols create mode 100644 tests/baselines/reference/ES5For-of30.types create mode 100644 tests/baselines/reference/ES5For-of31.symbols create mode 100644 tests/baselines/reference/ES5For-of31.types create mode 100644 tests/baselines/reference/ES5For-of33.symbols create mode 100644 tests/baselines/reference/ES5For-of33.types create mode 100644 tests/baselines/reference/ES5For-of34.symbols create mode 100644 tests/baselines/reference/ES5For-of34.types create mode 100644 tests/baselines/reference/ES5For-of35.symbols create mode 100644 tests/baselines/reference/ES5For-of35.types create mode 100644 tests/baselines/reference/ES5For-of36.symbols create mode 100644 tests/baselines/reference/ES5For-of36.types create mode 100644 tests/baselines/reference/ES5For-of7.symbols create mode 100644 tests/baselines/reference/ES5For-of7.types create mode 100644 tests/baselines/reference/ES5For-of8.symbols create mode 100644 tests/baselines/reference/ES5For-of8.types create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck10.symbols create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck10.types create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck11.symbols create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck11.types create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck12.symbols create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck12.types create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck7.symbols create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck7.types create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck8.symbols create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck8.types create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck9.symbols create mode 100644 tests/baselines/reference/ES5For-ofTypeCheck9.types create mode 100644 tests/baselines/reference/ES5SymbolProperty1.symbols create mode 100644 tests/baselines/reference/ES5SymbolProperty1.types create mode 100644 tests/baselines/reference/ES5SymbolProperty2.symbols create mode 100644 tests/baselines/reference/ES5SymbolProperty2.types create mode 100644 tests/baselines/reference/ES5SymbolProperty3.symbols create mode 100644 tests/baselines/reference/ES5SymbolProperty3.types create mode 100644 tests/baselines/reference/ES5SymbolProperty4.symbols create mode 100644 tests/baselines/reference/ES5SymbolProperty4.types create mode 100644 tests/baselines/reference/ES5SymbolProperty5.symbols create mode 100644 tests/baselines/reference/ES5SymbolProperty5.types create mode 100644 tests/baselines/reference/ES5SymbolProperty6.symbols create mode 100644 tests/baselines/reference/ES5SymbolProperty6.types create mode 100644 tests/baselines/reference/ES5SymbolProperty7.symbols create mode 100644 tests/baselines/reference/ES5SymbolProperty7.types create mode 100644 tests/baselines/reference/ExportAssignment7.symbols create mode 100644 tests/baselines/reference/ExportAssignment7.types create mode 100644 tests/baselines/reference/ExportAssignment8.symbols create mode 100644 tests/baselines/reference/ExportAssignment8.types create mode 100644 tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.symbols create mode 100644 tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.types create mode 100644 tests/baselines/reference/FunctionDeclaration10_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration10_es6.types create mode 100644 tests/baselines/reference/FunctionDeclaration12_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration12_es6.types create mode 100644 tests/baselines/reference/FunctionDeclaration13_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration13_es6.types create mode 100644 tests/baselines/reference/FunctionDeclaration3.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration3.types create mode 100644 tests/baselines/reference/FunctionDeclaration3_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration3_es6.types create mode 100644 tests/baselines/reference/FunctionDeclaration4.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration4.types create mode 100644 tests/baselines/reference/FunctionDeclaration5_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration5_es6.types create mode 100644 tests/baselines/reference/FunctionDeclaration6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration6.types create mode 100644 tests/baselines/reference/FunctionDeclaration6_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration6_es6.types create mode 100644 tests/baselines/reference/FunctionDeclaration7.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration7.types create mode 100644 tests/baselines/reference/FunctionDeclaration7_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration7_es6.types create mode 100644 tests/baselines/reference/FunctionDeclaration8_es6.symbols create mode 100644 tests/baselines/reference/FunctionDeclaration8_es6.types create mode 100644 tests/baselines/reference/FunctionPropertyAssignments2_es6.symbols create mode 100644 tests/baselines/reference/FunctionPropertyAssignments2_es6.types create mode 100644 tests/baselines/reference/FunctionPropertyAssignments3_es6.symbols create mode 100644 tests/baselines/reference/FunctionPropertyAssignments3_es6.types create mode 100644 tests/baselines/reference/FunctionPropertyAssignments4_es6.symbols create mode 100644 tests/baselines/reference/FunctionPropertyAssignments4_es6.types create mode 100644 tests/baselines/reference/FunctionPropertyAssignments5_es6.symbols create mode 100644 tests/baselines/reference/FunctionPropertyAssignments5_es6.types create mode 100644 tests/baselines/reference/FunctionPropertyAssignments6_es6.symbols create mode 100644 tests/baselines/reference/FunctionPropertyAssignments6_es6.types create mode 100644 tests/baselines/reference/InterfaceDeclaration8.symbols create mode 100644 tests/baselines/reference/InterfaceDeclaration8.types create mode 100644 tests/baselines/reference/InvalidNonInstantiatedModule.symbols create mode 100644 tests/baselines/reference/InvalidNonInstantiatedModule.types create mode 100644 tests/baselines/reference/MemberAccessorDeclaration15.symbols create mode 100644 tests/baselines/reference/MemberAccessorDeclaration15.types create mode 100644 tests/baselines/reference/MemberFunctionDeclaration3_es6.symbols create mode 100644 tests/baselines/reference/MemberFunctionDeclaration3_es6.types create mode 100644 tests/baselines/reference/MemberFunctionDeclaration4_es6.symbols create mode 100644 tests/baselines/reference/MemberFunctionDeclaration4_es6.types create mode 100644 tests/baselines/reference/MemberFunctionDeclaration5_es6.symbols create mode 100644 tests/baselines/reference/MemberFunctionDeclaration5_es6.types create mode 100644 tests/baselines/reference/MemberFunctionDeclaration6_es6.symbols create mode 100644 tests/baselines/reference/MemberFunctionDeclaration6_es6.types create mode 100644 tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols create mode 100644 tests/baselines/reference/MemberFunctionDeclaration8_es6.types create mode 100644 tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.symbols create mode 100644 tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.types create mode 100644 tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.symbols create mode 100644 tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.types create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.symbols create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.types create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.symbols create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.types create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.symbols create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.types create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.symbols create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.types create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.symbols create mode 100644 tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.types create mode 100644 tests/baselines/reference/NonInitializedExportInInternalModule.symbols create mode 100644 tests/baselines/reference/NonInitializedExportInInternalModule.types create mode 100644 tests/baselines/reference/ParameterList13.symbols create mode 100644 tests/baselines/reference/ParameterList13.types create mode 100644 tests/baselines/reference/ParameterList4.symbols create mode 100644 tests/baselines/reference/ParameterList4.types create mode 100644 tests/baselines/reference/ParameterList5.symbols create mode 100644 tests/baselines/reference/ParameterList5.types create mode 100644 tests/baselines/reference/ParameterList6.symbols create mode 100644 tests/baselines/reference/ParameterList6.types create mode 100644 tests/baselines/reference/ParameterList7.symbols create mode 100644 tests/baselines/reference/ParameterList7.types create mode 100644 tests/baselines/reference/ParameterList8.symbols create mode 100644 tests/baselines/reference/ParameterList8.types create mode 100644 tests/baselines/reference/Protected1.symbols create mode 100644 tests/baselines/reference/Protected1.types create mode 100644 tests/baselines/reference/Protected2.symbols create mode 100644 tests/baselines/reference/Protected2.types create mode 100644 tests/baselines/reference/Protected4.symbols create mode 100644 tests/baselines/reference/Protected4.types create mode 100644 tests/baselines/reference/Protected6.symbols create mode 100644 tests/baselines/reference/Protected6.types create mode 100644 tests/baselines/reference/Protected7.symbols create mode 100644 tests/baselines/reference/Protected7.types create mode 100644 tests/baselines/reference/TemplateExpression1.symbols create mode 100644 tests/baselines/reference/TemplateExpression1.types create mode 100644 tests/baselines/reference/TupleType3.symbols create mode 100644 tests/baselines/reference/TupleType3.types create mode 100644 tests/baselines/reference/TupleType4.symbols create mode 100644 tests/baselines/reference/TupleType4.types create mode 100644 tests/baselines/reference/TupleType5.symbols create mode 100644 tests/baselines/reference/TupleType5.types create mode 100644 tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.symbols create mode 100644 tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.types create mode 100644 tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.symbols create mode 100644 tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types create mode 100644 tests/baselines/reference/TypeArgumentList1.symbols create mode 100644 tests/baselines/reference/TypeArgumentList1.types create mode 100644 tests/baselines/reference/VariableDeclaration11_es6.symbols create mode 100644 tests/baselines/reference/VariableDeclaration11_es6.types create mode 100644 tests/baselines/reference/VariableDeclaration13_es6.symbols create mode 100644 tests/baselines/reference/VariableDeclaration13_es6.types create mode 100644 tests/baselines/reference/VariableDeclaration1_es6.symbols create mode 100644 tests/baselines/reference/VariableDeclaration1_es6.types create mode 100644 tests/baselines/reference/VariableDeclaration2_es6.symbols create mode 100644 tests/baselines/reference/VariableDeclaration2_es6.types create mode 100644 tests/baselines/reference/VariableDeclaration4_es6.symbols create mode 100644 tests/baselines/reference/VariableDeclaration4_es6.types create mode 100644 tests/baselines/reference/VariableDeclaration6_es6.symbols create mode 100644 tests/baselines/reference/VariableDeclaration6_es6.types create mode 100644 tests/baselines/reference/YieldExpression10_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression10_es6.types create mode 100644 tests/baselines/reference/YieldExpression11_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression11_es6.types create mode 100644 tests/baselines/reference/YieldExpression12_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression12_es6.types create mode 100644 tests/baselines/reference/YieldExpression14_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression14_es6.types create mode 100644 tests/baselines/reference/YieldExpression15_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression15_es6.types create mode 100644 tests/baselines/reference/YieldExpression16_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression16_es6.types create mode 100644 tests/baselines/reference/YieldExpression17_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression17_es6.types create mode 100644 tests/baselines/reference/YieldExpression18_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression18_es6.types create mode 100644 tests/baselines/reference/YieldExpression1_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression1_es6.types create mode 100644 tests/baselines/reference/YieldExpression2_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression2_es6.types create mode 100644 tests/baselines/reference/YieldExpression5_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression5_es6.types create mode 100644 tests/baselines/reference/YieldExpression6_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression6_es6.types create mode 100644 tests/baselines/reference/YieldExpression8_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression8_es6.types create mode 100644 tests/baselines/reference/YieldExpression9_es6.symbols create mode 100644 tests/baselines/reference/YieldExpression9_es6.types create mode 100644 tests/baselines/reference/YieldStarExpression1_es6.symbols create mode 100644 tests/baselines/reference/YieldStarExpression1_es6.types create mode 100644 tests/baselines/reference/YieldStarExpression2_es6.symbols create mode 100644 tests/baselines/reference/YieldStarExpression2_es6.types create mode 100644 tests/baselines/reference/YieldStarExpression3_es6.symbols create mode 100644 tests/baselines/reference/YieldStarExpression3_es6.types create mode 100644 tests/baselines/reference/abstractClassInLocalScopeIsAbstract.symbols create mode 100644 tests/baselines/reference/abstractClassInLocalScopeIsAbstract.types create mode 100644 tests/baselines/reference/abstractPropertyNegative.symbols create mode 100644 tests/baselines/reference/abstractPropertyNegative.types create mode 100644 tests/baselines/reference/accessInstanceMemberFromStaticMethod01.symbols create mode 100644 tests/baselines/reference/accessInstanceMemberFromStaticMethod01.types create mode 100644 tests/baselines/reference/accessStaticMemberFromInstanceMethod01.symbols create mode 100644 tests/baselines/reference/accessStaticMemberFromInstanceMethod01.types create mode 100644 tests/baselines/reference/accessibilityModifiers.symbols create mode 100644 tests/baselines/reference/accessibilityModifiers.types create mode 100644 tests/baselines/reference/accessorParameterAccessibilityModifier.symbols create mode 100644 tests/baselines/reference/accessorParameterAccessibilityModifier.types create mode 100644 tests/baselines/reference/accessorWithES3.symbols create mode 100644 tests/baselines/reference/accessorWithES3.types create mode 100644 tests/baselines/reference/accessorWithInitializer.symbols create mode 100644 tests/baselines/reference/accessorWithInitializer.types create mode 100644 tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.symbols create mode 100644 tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.types create mode 100644 tests/baselines/reference/accessorWithRestParam.symbols create mode 100644 tests/baselines/reference/accessorWithRestParam.types create mode 100644 tests/baselines/reference/accessorWithoutBody1.symbols create mode 100644 tests/baselines/reference/accessorWithoutBody1.types create mode 100644 tests/baselines/reference/accessorWithoutBody2.symbols create mode 100644 tests/baselines/reference/accessorWithoutBody2.types create mode 100644 tests/baselines/reference/accessorsAreNotContextuallyTyped.symbols create mode 100644 tests/baselines/reference/accessorsAreNotContextuallyTyped.types create mode 100644 tests/baselines/reference/accessorsEmit.symbols create mode 100644 tests/baselines/reference/accessorsEmit.types create mode 100644 tests/baselines/reference/accessorsInAmbientContext.symbols create mode 100644 tests/baselines/reference/accessorsInAmbientContext.types create mode 100644 tests/baselines/reference/accessorsNotAllowedInES3.symbols create mode 100644 tests/baselines/reference/accessorsNotAllowedInES3.types create mode 100644 tests/baselines/reference/accessors_spec_section-4.5_error-cases.symbols create mode 100644 tests/baselines/reference/accessors_spec_section-4.5_error-cases.types create mode 100644 tests/baselines/reference/accessors_spec_section-4.5_inference.symbols create mode 100644 tests/baselines/reference/accessors_spec_section-4.5_inference.types create mode 100644 tests/baselines/reference/addMoreOverloadsToBaseSignature.symbols create mode 100644 tests/baselines/reference/addMoreOverloadsToBaseSignature.types create mode 100644 tests/baselines/reference/additionOperatorWithInvalidOperands.symbols create mode 100644 tests/baselines/reference/additionOperatorWithInvalidOperands.types create mode 100644 tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols create mode 100644 tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types create mode 100644 tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.symbols create mode 100644 tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.types create mode 100644 tests/baselines/reference/additionOperatorWithTypeParameter.symbols create mode 100644 tests/baselines/reference/additionOperatorWithTypeParameter.types create mode 100644 tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols create mode 100644 tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types create mode 100644 tests/baselines/reference/aliasAssignments.symbols create mode 100644 tests/baselines/reference/aliasAssignments.types create mode 100644 tests/baselines/reference/aliasBug.symbols create mode 100644 tests/baselines/reference/aliasBug.types create mode 100644 tests/baselines/reference/aliasErrors.symbols create mode 100644 tests/baselines/reference/aliasErrors.types create mode 100644 tests/baselines/reference/aliasInaccessibleModule.symbols create mode 100644 tests/baselines/reference/aliasInaccessibleModule.types create mode 100644 tests/baselines/reference/aliasInaccessibleModule2.symbols create mode 100644 tests/baselines/reference/aliasInaccessibleModule2.types create mode 100644 tests/baselines/reference/aliasOnMergedModuleInterface.symbols create mode 100644 tests/baselines/reference/aliasOnMergedModuleInterface.types create mode 100644 tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.symbols create mode 100644 tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.types create mode 100644 tests/baselines/reference/aliasesInSystemModule1.symbols create mode 100644 tests/baselines/reference/aliasesInSystemModule1.types create mode 100644 tests/baselines/reference/aliasesInSystemModule2.symbols create mode 100644 tests/baselines/reference/aliasesInSystemModule2.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports10.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports10.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports3.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports3.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports6.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports6.types create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports8.symbols create mode 100644 tests/baselines/reference/allowSyntheticDefaultImports8.types create mode 100644 tests/baselines/reference/alwaysStrict.symbols create mode 100644 tests/baselines/reference/alwaysStrict.types create mode 100644 tests/baselines/reference/alwaysStrictES6.symbols create mode 100644 tests/baselines/reference/alwaysStrictES6.types create mode 100644 tests/baselines/reference/alwaysStrictModule.symbols create mode 100644 tests/baselines/reference/alwaysStrictModule.types create mode 100644 tests/baselines/reference/alwaysStrictModule2.symbols create mode 100644 tests/baselines/reference/alwaysStrictModule2.types create mode 100644 tests/baselines/reference/alwaysStrictNoImplicitUseStrict.symbols create mode 100644 tests/baselines/reference/alwaysStrictNoImplicitUseStrict.types create mode 100644 tests/baselines/reference/ambientClassOverloadForFunction.symbols create mode 100644 tests/baselines/reference/ambientClassOverloadForFunction.types create mode 100644 tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.symbols create mode 100644 tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.types create mode 100644 tests/baselines/reference/ambientEnum1.symbols create mode 100644 tests/baselines/reference/ambientEnum1.types create mode 100644 tests/baselines/reference/ambientErrors.symbols create mode 100644 tests/baselines/reference/ambientErrors.types create mode 100644 tests/baselines/reference/ambientErrors1.symbols create mode 100644 tests/baselines/reference/ambientErrors1.types create mode 100644 tests/baselines/reference/ambientExportDefaultErrors.symbols create mode 100644 tests/baselines/reference/ambientExportDefaultErrors.types create mode 100644 tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.symbols create mode 100644 tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.types create mode 100644 tests/baselines/reference/ambientExternalModuleInsideNonAmbient.symbols create mode 100644 tests/baselines/reference/ambientExternalModuleInsideNonAmbient.types create mode 100644 tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.symbols create mode 100644 tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.types create mode 100644 tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.symbols create mode 100644 tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.types create mode 100644 tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.symbols create mode 100644 tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.types create mode 100644 tests/baselines/reference/ambientGetters.symbols create mode 100644 tests/baselines/reference/ambientGetters.types create mode 100644 tests/baselines/reference/ambientStatement1.symbols create mode 100644 tests/baselines/reference/ambientStatement1.types create mode 100644 tests/baselines/reference/ambientWithStatements.symbols create mode 100644 tests/baselines/reference/ambientWithStatements.types create mode 100644 tests/baselines/reference/ambiguousGenericAssertion1.symbols create mode 100644 tests/baselines/reference/ambiguousGenericAssertion1.types create mode 100644 tests/baselines/reference/ambiguousOverload.symbols create mode 100644 tests/baselines/reference/ambiguousOverload.types create mode 100644 tests/baselines/reference/amdDependencyComment1.symbols create mode 100644 tests/baselines/reference/amdDependencyComment1.types create mode 100644 tests/baselines/reference/amdDependencyComment2.symbols create mode 100644 tests/baselines/reference/amdDependencyComment2.types create mode 100644 tests/baselines/reference/amdDependencyCommentName1.symbols create mode 100644 tests/baselines/reference/amdDependencyCommentName1.types create mode 100644 tests/baselines/reference/amdDependencyCommentName2.symbols create mode 100644 tests/baselines/reference/amdDependencyCommentName2.types create mode 100644 tests/baselines/reference/amdDependencyCommentName3.symbols create mode 100644 tests/baselines/reference/amdDependencyCommentName3.types create mode 100644 tests/baselines/reference/amdDependencyCommentName4.symbols create mode 100644 tests/baselines/reference/amdDependencyCommentName4.types create mode 100644 tests/baselines/reference/amdModuleName2.symbols create mode 100644 tests/baselines/reference/amdModuleName2.types create mode 100644 tests/baselines/reference/anonymousClassExpression2.symbols create mode 100644 tests/baselines/reference/anonymousClassExpression2.types create mode 100644 tests/baselines/reference/anonymousModules.symbols create mode 100644 tests/baselines/reference/anonymousModules.types create mode 100644 tests/baselines/reference/anyAsConstructor.symbols create mode 100644 tests/baselines/reference/anyAsConstructor.types create mode 100644 tests/baselines/reference/anyAsGenericFunctionCall.symbols create mode 100644 tests/baselines/reference/anyAsGenericFunctionCall.types create mode 100644 tests/baselines/reference/anyDeclare.symbols create mode 100644 tests/baselines/reference/anyDeclare.types create mode 100644 tests/baselines/reference/anyIdenticalToItself.symbols create mode 100644 tests/baselines/reference/anyIdenticalToItself.types create mode 100644 tests/baselines/reference/anyIndexedAccessArrayNoException.symbols create mode 100644 tests/baselines/reference/anyIndexedAccessArrayNoException.types create mode 100644 tests/baselines/reference/apparentTypeSubtyping.symbols create mode 100644 tests/baselines/reference/apparentTypeSubtyping.types create mode 100644 tests/baselines/reference/apparentTypeSupertype.symbols create mode 100644 tests/baselines/reference/apparentTypeSupertype.types create mode 100644 tests/baselines/reference/argumentExpressionContextualTyping.symbols create mode 100644 tests/baselines/reference/argumentExpressionContextualTyping.types create mode 100644 tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.symbols create mode 100644 tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.types create mode 100644 tests/baselines/reference/argumentsObjectIterator01_ES5.symbols create mode 100644 tests/baselines/reference/argumentsObjectIterator01_ES5.types create mode 100644 tests/baselines/reference/argumentsObjectIterator02_ES5.symbols create mode 100644 tests/baselines/reference/argumentsObjectIterator02_ES5.types create mode 100644 tests/baselines/reference/argumentsObjectIterator03_ES5.symbols create mode 100644 tests/baselines/reference/argumentsObjectIterator03_ES5.types create mode 100644 tests/baselines/reference/arithAssignTyping.symbols create mode 100644 tests/baselines/reference/arithAssignTyping.types create mode 100644 tests/baselines/reference/arithmeticOnInvalidTypes.symbols create mode 100644 tests/baselines/reference/arithmeticOnInvalidTypes.types create mode 100644 tests/baselines/reference/arithmeticOnInvalidTypes2.symbols create mode 100644 tests/baselines/reference/arithmeticOnInvalidTypes2.types create mode 100644 tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols create mode 100644 tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types create mode 100644 tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols create mode 100644 tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types create mode 100644 tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.symbols create mode 100644 tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.types create mode 100644 tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols create mode 100644 tests/baselines/reference/arithmeticOperatorWithTypeParameter.types create mode 100644 tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols create mode 100644 tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types create mode 100644 tests/baselines/reference/arityAndOrderCompatibility01.symbols create mode 100644 tests/baselines/reference/arityAndOrderCompatibility01.types create mode 100644 tests/baselines/reference/arrayAssignmentTest1.symbols create mode 100644 tests/baselines/reference/arrayAssignmentTest1.types create mode 100644 tests/baselines/reference/arrayAssignmentTest2.symbols create mode 100644 tests/baselines/reference/arrayAssignmentTest2.types create mode 100644 tests/baselines/reference/arrayAssignmentTest3.symbols create mode 100644 tests/baselines/reference/arrayAssignmentTest3.types create mode 100644 tests/baselines/reference/arrayAssignmentTest4.symbols create mode 100644 tests/baselines/reference/arrayAssignmentTest4.types create mode 100644 tests/baselines/reference/arrayAssignmentTest5.symbols create mode 100644 tests/baselines/reference/arrayAssignmentTest5.types create mode 100644 tests/baselines/reference/arrayCast.symbols create mode 100644 tests/baselines/reference/arrayCast.types create mode 100644 tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols create mode 100644 tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types create mode 100644 tests/baselines/reference/arrayLiteralExpressionContextualTyping.symbols create mode 100644 tests/baselines/reference/arrayLiteralExpressionContextualTyping.types create mode 100644 tests/baselines/reference/arrayLiteralTypeInference.symbols create mode 100644 tests/baselines/reference/arrayLiteralTypeInference.types create mode 100644 tests/baselines/reference/arrayLiterals.symbols create mode 100644 tests/baselines/reference/arrayLiterals.types create mode 100644 tests/baselines/reference/arrayLiterals3.symbols create mode 100644 tests/baselines/reference/arrayLiterals3.types create mode 100644 tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.symbols create mode 100644 tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.types create mode 100644 tests/baselines/reference/arrayReferenceWithoutTypeArgs.symbols create mode 100644 tests/baselines/reference/arrayReferenceWithoutTypeArgs.types create mode 100644 tests/baselines/reference/arraySigChecking.symbols create mode 100644 tests/baselines/reference/arraySigChecking.types create mode 100644 tests/baselines/reference/arrayTypeOfFunctionTypes.symbols create mode 100644 tests/baselines/reference/arrayTypeOfFunctionTypes.types create mode 100644 tests/baselines/reference/arrayTypeOfFunctionTypes2.symbols create mode 100644 tests/baselines/reference/arrayTypeOfFunctionTypes2.types create mode 100644 tests/baselines/reference/arrayTypeOfTypeOf.symbols create mode 100644 tests/baselines/reference/arrayTypeOfTypeOf.types create mode 100644 tests/baselines/reference/arrowFunctionContexts.symbols create mode 100644 tests/baselines/reference/arrowFunctionContexts.types create mode 100644 tests/baselines/reference/arrowFunctionErrorSpan.symbols create mode 100644 tests/baselines/reference/arrowFunctionErrorSpan.types create mode 100644 tests/baselines/reference/arrowFunctionInConstructorArgument1.symbols create mode 100644 tests/baselines/reference/arrowFunctionInConstructorArgument1.types create mode 100644 tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.symbols create mode 100644 tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.types create mode 100644 tests/baselines/reference/arrowFunctionsMissingTokens.symbols create mode 100644 tests/baselines/reference/arrowFunctionsMissingTokens.types create mode 100644 tests/baselines/reference/asOperator2.symbols create mode 100644 tests/baselines/reference/asOperator2.types create mode 100644 tests/baselines/reference/asOperatorAmbiguity.symbols create mode 100644 tests/baselines/reference/asOperatorAmbiguity.types create mode 100644 tests/baselines/reference/asOperatorContextualType.symbols create mode 100644 tests/baselines/reference/asOperatorContextualType.types create mode 100644 tests/baselines/reference/asOperatorNames.symbols create mode 100644 tests/baselines/reference/asOperatorNames.types create mode 100644 tests/baselines/reference/asiAbstract.symbols create mode 100644 tests/baselines/reference/asiAbstract.types create mode 100644 tests/baselines/reference/asiPreventsParsingAsInterface05.symbols create mode 100644 tests/baselines/reference/asiPreventsParsingAsInterface05.types create mode 100644 tests/baselines/reference/asiPublicPrivateProtected.symbols create mode 100644 tests/baselines/reference/asiPublicPrivateProtected.types create mode 100644 tests/baselines/reference/asiReturn.symbols create mode 100644 tests/baselines/reference/asiReturn.types create mode 100644 tests/baselines/reference/assertInWrapSomeTypeParameter.symbols create mode 100644 tests/baselines/reference/assertInWrapSomeTypeParameter.types create mode 100644 tests/baselines/reference/assignAnyToEveryType.symbols create mode 100644 tests/baselines/reference/assignAnyToEveryType.types create mode 100644 tests/baselines/reference/assignFromBooleanInterface.symbols create mode 100644 tests/baselines/reference/assignFromBooleanInterface.types create mode 100644 tests/baselines/reference/assignFromBooleanInterface2.symbols create mode 100644 tests/baselines/reference/assignFromBooleanInterface2.types create mode 100644 tests/baselines/reference/assignFromNumberInterface.symbols create mode 100644 tests/baselines/reference/assignFromNumberInterface.types create mode 100644 tests/baselines/reference/assignFromNumberInterface2.symbols create mode 100644 tests/baselines/reference/assignFromNumberInterface2.types create mode 100644 tests/baselines/reference/assignFromStringInterface.symbols create mode 100644 tests/baselines/reference/assignFromStringInterface.types create mode 100644 tests/baselines/reference/assignFromStringInterface2.symbols create mode 100644 tests/baselines/reference/assignFromStringInterface2.types create mode 100644 tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.symbols create mode 100644 tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.types create mode 100644 tests/baselines/reference/assignToEnum.symbols create mode 100644 tests/baselines/reference/assignToEnum.types create mode 100644 tests/baselines/reference/assignToExistingClass.symbols create mode 100644 tests/baselines/reference/assignToExistingClass.types create mode 100644 tests/baselines/reference/assignToFn.symbols create mode 100644 tests/baselines/reference/assignToFn.types create mode 100644 tests/baselines/reference/assignToInvalidLHS.symbols create mode 100644 tests/baselines/reference/assignToInvalidLHS.types create mode 100644 tests/baselines/reference/assignToModule.symbols create mode 100644 tests/baselines/reference/assignToModule.types create mode 100644 tests/baselines/reference/assigningFromObjectToAnythingElse.symbols create mode 100644 tests/baselines/reference/assigningFromObjectToAnythingElse.types create mode 100644 tests/baselines/reference/assignmentCompat1.symbols create mode 100644 tests/baselines/reference/assignmentCompat1.types create mode 100644 tests/baselines/reference/assignmentCompatBetweenTupleAndArray.symbols create mode 100644 tests/baselines/reference/assignmentCompatBetweenTupleAndArray.types create mode 100644 tests/baselines/reference/assignmentCompatBug2.symbols create mode 100644 tests/baselines/reference/assignmentCompatBug2.types create mode 100644 tests/baselines/reference/assignmentCompatBug3.symbols create mode 100644 tests/baselines/reference/assignmentCompatBug3.types create mode 100644 tests/baselines/reference/assignmentCompatBug5.symbols create mode 100644 tests/baselines/reference/assignmentCompatBug5.types create mode 100644 tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.symbols create mode 100644 tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.types create mode 100644 tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.symbols create mode 100644 tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.types create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignatures.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignatures.types create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignatures2.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignatures2.types create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignatures4.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignatures4.types create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.types create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.types create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignatures.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignatures.types create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignatures2.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignatures2.types create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignatures4.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignatures4.types create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.types create mode 100644 tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types create mode 100644 tests/baselines/reference/assignmentCompatWithNumericIndexer.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithNumericIndexer.types create mode 100644 tests/baselines/reference/assignmentCompatWithNumericIndexer2.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithNumericIndexer2.types create mode 100644 tests/baselines/reference/assignmentCompatWithNumericIndexer3.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithNumericIndexer3.types create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembers4.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembers4.types create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembers5.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembers5.types create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.types create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.types create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.types create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.types create mode 100644 tests/baselines/reference/assignmentCompatWithOverloads.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithOverloads.types create mode 100644 tests/baselines/reference/assignmentCompatWithStringIndexer.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithStringIndexer.types create mode 100644 tests/baselines/reference/assignmentCompatWithStringIndexer2.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithStringIndexer2.types create mode 100644 tests/baselines/reference/assignmentCompatWithStringIndexer3.symbols create mode 100644 tests/baselines/reference/assignmentCompatWithStringIndexer3.types create mode 100644 tests/baselines/reference/assignmentCompatability11.symbols create mode 100644 tests/baselines/reference/assignmentCompatability11.types create mode 100644 tests/baselines/reference/assignmentCompatability12.symbols create mode 100644 tests/baselines/reference/assignmentCompatability12.types create mode 100644 tests/baselines/reference/assignmentCompatability13.symbols create mode 100644 tests/baselines/reference/assignmentCompatability13.types create mode 100644 tests/baselines/reference/assignmentCompatability14.symbols create mode 100644 tests/baselines/reference/assignmentCompatability14.types create mode 100644 tests/baselines/reference/assignmentCompatability15.symbols create mode 100644 tests/baselines/reference/assignmentCompatability15.types create mode 100644 tests/baselines/reference/assignmentCompatability16.symbols create mode 100644 tests/baselines/reference/assignmentCompatability16.types create mode 100644 tests/baselines/reference/assignmentCompatability17.symbols create mode 100644 tests/baselines/reference/assignmentCompatability17.types create mode 100644 tests/baselines/reference/assignmentCompatability18.symbols create mode 100644 tests/baselines/reference/assignmentCompatability18.types create mode 100644 tests/baselines/reference/assignmentCompatability19.symbols create mode 100644 tests/baselines/reference/assignmentCompatability19.types create mode 100644 tests/baselines/reference/assignmentCompatability20.symbols create mode 100644 tests/baselines/reference/assignmentCompatability20.types create mode 100644 tests/baselines/reference/assignmentCompatability21.symbols create mode 100644 tests/baselines/reference/assignmentCompatability21.types create mode 100644 tests/baselines/reference/assignmentCompatability22.symbols create mode 100644 tests/baselines/reference/assignmentCompatability22.types create mode 100644 tests/baselines/reference/assignmentCompatability23.symbols create mode 100644 tests/baselines/reference/assignmentCompatability23.types create mode 100644 tests/baselines/reference/assignmentCompatability24.symbols create mode 100644 tests/baselines/reference/assignmentCompatability24.types create mode 100644 tests/baselines/reference/assignmentCompatability25.symbols create mode 100644 tests/baselines/reference/assignmentCompatability25.types create mode 100644 tests/baselines/reference/assignmentCompatability26.symbols create mode 100644 tests/baselines/reference/assignmentCompatability26.types create mode 100644 tests/baselines/reference/assignmentCompatability27.symbols create mode 100644 tests/baselines/reference/assignmentCompatability27.types create mode 100644 tests/baselines/reference/assignmentCompatability28.symbols create mode 100644 tests/baselines/reference/assignmentCompatability28.types create mode 100644 tests/baselines/reference/assignmentCompatability29.symbols create mode 100644 tests/baselines/reference/assignmentCompatability29.types create mode 100644 tests/baselines/reference/assignmentCompatability30.symbols create mode 100644 tests/baselines/reference/assignmentCompatability30.types create mode 100644 tests/baselines/reference/assignmentCompatability31.symbols create mode 100644 tests/baselines/reference/assignmentCompatability31.types create mode 100644 tests/baselines/reference/assignmentCompatability32.symbols create mode 100644 tests/baselines/reference/assignmentCompatability32.types create mode 100644 tests/baselines/reference/assignmentCompatability33.symbols create mode 100644 tests/baselines/reference/assignmentCompatability33.types create mode 100644 tests/baselines/reference/assignmentCompatability34.symbols create mode 100644 tests/baselines/reference/assignmentCompatability34.types create mode 100644 tests/baselines/reference/assignmentCompatability35.symbols create mode 100644 tests/baselines/reference/assignmentCompatability35.types create mode 100644 tests/baselines/reference/assignmentCompatability37.symbols create mode 100644 tests/baselines/reference/assignmentCompatability37.types create mode 100644 tests/baselines/reference/assignmentCompatability38.symbols create mode 100644 tests/baselines/reference/assignmentCompatability38.types create mode 100644 tests/baselines/reference/assignmentCompatability39.symbols create mode 100644 tests/baselines/reference/assignmentCompatability39.types create mode 100644 tests/baselines/reference/assignmentCompatability40.symbols create mode 100644 tests/baselines/reference/assignmentCompatability40.types create mode 100644 tests/baselines/reference/assignmentCompatability41.symbols create mode 100644 tests/baselines/reference/assignmentCompatability41.types create mode 100644 tests/baselines/reference/assignmentCompatability42.symbols create mode 100644 tests/baselines/reference/assignmentCompatability42.types create mode 100644 tests/baselines/reference/assignmentCompatability43.symbols create mode 100644 tests/baselines/reference/assignmentCompatability43.types create mode 100644 tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.symbols create mode 100644 tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.types create mode 100644 tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.symbols create mode 100644 tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.types create mode 100644 tests/baselines/reference/assignmentLHSIsValue.symbols create mode 100644 tests/baselines/reference/assignmentLHSIsValue.types create mode 100644 tests/baselines/reference/assignmentRestElementWithErrorSourceType.symbols create mode 100644 tests/baselines/reference/assignmentRestElementWithErrorSourceType.types create mode 100644 tests/baselines/reference/assignmentToFunction.symbols create mode 100644 tests/baselines/reference/assignmentToFunction.types create mode 100644 tests/baselines/reference/assignmentToObject.symbols create mode 100644 tests/baselines/reference/assignmentToObject.types create mode 100644 tests/baselines/reference/assignmentToObjectAndFunction.symbols create mode 100644 tests/baselines/reference/assignmentToObjectAndFunction.types create mode 100644 tests/baselines/reference/assignmentToParenthesizedExpression1.symbols create mode 100644 tests/baselines/reference/assignmentToParenthesizedExpression1.types create mode 100644 tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols create mode 100644 tests/baselines/reference/assignmentToParenthesizedIdentifiers.types create mode 100644 tests/baselines/reference/assignmentToReferenceTypes.symbols create mode 100644 tests/baselines/reference/assignmentToReferenceTypes.types create mode 100644 tests/baselines/reference/assignments.symbols create mode 100644 tests/baselines/reference/assignments.types create mode 100644 tests/baselines/reference/asyncArrowFunction10_es2017.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction10_es2017.types create mode 100644 tests/baselines/reference/asyncArrowFunction10_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction10_es5.types create mode 100644 tests/baselines/reference/asyncArrowFunction10_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction10_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction3_es2017.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction3_es2017.types create mode 100644 tests/baselines/reference/asyncArrowFunction3_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction3_es5.types create mode 100644 tests/baselines/reference/asyncArrowFunction3_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction3_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction5_es2017.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction5_es2017.types create mode 100644 tests/baselines/reference/asyncArrowFunction5_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction5_es5.types create mode 100644 tests/baselines/reference/asyncArrowFunction5_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction5_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction6_es2017.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction6_es2017.types create mode 100644 tests/baselines/reference/asyncArrowFunction6_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction6_es5.types create mode 100644 tests/baselines/reference/asyncArrowFunction6_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction6_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction7_es2017.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction7_es2017.types create mode 100644 tests/baselines/reference/asyncArrowFunction7_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction7_es5.types create mode 100644 tests/baselines/reference/asyncArrowFunction7_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction7_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction8_es2017.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction8_es2017.types create mode 100644 tests/baselines/reference/asyncArrowFunction8_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction8_es5.types create mode 100644 tests/baselines/reference/asyncArrowFunction8_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction8_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunction9_es2017.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction9_es2017.types create mode 100644 tests/baselines/reference/asyncArrowFunction9_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction9_es5.types create mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.symbols create mode 100644 tests/baselines/reference/asyncArrowFunction9_es6.types create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.symbols create mode 100644 tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.types create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es2017.symbols create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es2017.types create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es5.symbols create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es5.types create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols create mode 100644 tests/baselines/reference/asyncAwaitIsolatedModules_es6.types create mode 100644 tests/baselines/reference/asyncClass_es5.symbols create mode 100644 tests/baselines/reference/asyncClass_es5.types create mode 100644 tests/baselines/reference/asyncClass_es6.symbols create mode 100644 tests/baselines/reference/asyncClass_es6.types create mode 100644 tests/baselines/reference/asyncConstructor_es5.symbols create mode 100644 tests/baselines/reference/asyncConstructor_es5.types create mode 100644 tests/baselines/reference/asyncConstructor_es6.symbols create mode 100644 tests/baselines/reference/asyncConstructor_es6.types create mode 100644 tests/baselines/reference/asyncDeclare_es5.symbols create mode 100644 tests/baselines/reference/asyncDeclare_es5.types create mode 100644 tests/baselines/reference/asyncDeclare_es6.symbols create mode 100644 tests/baselines/reference/asyncDeclare_es6.types create mode 100644 tests/baselines/reference/asyncEnum_es5.symbols create mode 100644 tests/baselines/reference/asyncEnum_es5.types create mode 100644 tests/baselines/reference/asyncEnum_es6.symbols create mode 100644 tests/baselines/reference/asyncEnum_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration10_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration12_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration13_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration15_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration15_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration15_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration3_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration5_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration6_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration7_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration8_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es2017.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es2017.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es5.types create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclaration9_es6.types create mode 100644 tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.symbols create mode 100644 tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.types create mode 100644 tests/baselines/reference/asyncFunctionNoReturnType.symbols create mode 100644 tests/baselines/reference/asyncFunctionNoReturnType.types create mode 100644 tests/baselines/reference/asyncGetter_es5.symbols create mode 100644 tests/baselines/reference/asyncGetter_es5.types create mode 100644 tests/baselines/reference/asyncGetter_es6.symbols create mode 100644 tests/baselines/reference/asyncGetter_es6.types create mode 100644 tests/baselines/reference/asyncImportedPromise_es6.symbols create mode 100644 tests/baselines/reference/asyncImportedPromise_es6.types create mode 100644 tests/baselines/reference/asyncInterface_es5.symbols create mode 100644 tests/baselines/reference/asyncInterface_es5.types create mode 100644 tests/baselines/reference/asyncInterface_es6.symbols create mode 100644 tests/baselines/reference/asyncInterface_es6.types create mode 100644 tests/baselines/reference/asyncModule_es5.symbols create mode 100644 tests/baselines/reference/asyncModule_es5.types create mode 100644 tests/baselines/reference/asyncModule_es6.symbols create mode 100644 tests/baselines/reference/asyncModule_es6.types create mode 100644 tests/baselines/reference/asyncQualifiedReturnType_es6.symbols create mode 100644 tests/baselines/reference/asyncQualifiedReturnType_es6.types create mode 100644 tests/baselines/reference/asyncSetter_es5.symbols create mode 100644 tests/baselines/reference/asyncSetter_es5.types create mode 100644 tests/baselines/reference/asyncSetter_es6.symbols create mode 100644 tests/baselines/reference/asyncSetter_es6.types create mode 100644 tests/baselines/reference/augmentExportEquals1.symbols create mode 100644 tests/baselines/reference/augmentExportEquals1.types create mode 100644 tests/baselines/reference/augmentExportEquals1_1.symbols create mode 100644 tests/baselines/reference/augmentExportEquals1_1.types create mode 100644 tests/baselines/reference/augmentExportEquals2.symbols create mode 100644 tests/baselines/reference/augmentExportEquals2.types create mode 100644 tests/baselines/reference/augmentExportEquals2_1.symbols create mode 100644 tests/baselines/reference/augmentExportEquals2_1.types create mode 100644 tests/baselines/reference/augmentExportEquals7.symbols create mode 100644 tests/baselines/reference/augmentExportEquals7.types create mode 100644 tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.symbols create mode 100644 tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.types create mode 100644 tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.symbols create mode 100644 tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.types create mode 100644 tests/baselines/reference/augmentedTypesClass.symbols create mode 100644 tests/baselines/reference/augmentedTypesClass.types create mode 100644 tests/baselines/reference/augmentedTypesClass2.symbols create mode 100644 tests/baselines/reference/augmentedTypesClass2.types create mode 100644 tests/baselines/reference/augmentedTypesClass2a.symbols create mode 100644 tests/baselines/reference/augmentedTypesClass2a.types create mode 100644 tests/baselines/reference/augmentedTypesClass4.symbols create mode 100644 tests/baselines/reference/augmentedTypesClass4.types create mode 100644 tests/baselines/reference/augmentedTypesEnum.symbols create mode 100644 tests/baselines/reference/augmentedTypesEnum.types create mode 100644 tests/baselines/reference/augmentedTypesEnum2.symbols create mode 100644 tests/baselines/reference/augmentedTypesEnum2.types create mode 100644 tests/baselines/reference/augmentedTypesEnum3.symbols create mode 100644 tests/baselines/reference/augmentedTypesEnum3.types create mode 100644 tests/baselines/reference/augmentedTypesFunction.symbols create mode 100644 tests/baselines/reference/augmentedTypesFunction.types create mode 100644 tests/baselines/reference/augmentedTypesInterface.symbols create mode 100644 tests/baselines/reference/augmentedTypesInterface.types create mode 100644 tests/baselines/reference/augmentedTypesModules.symbols create mode 100644 tests/baselines/reference/augmentedTypesModules.types create mode 100644 tests/baselines/reference/augmentedTypesModules2.symbols create mode 100644 tests/baselines/reference/augmentedTypesModules2.types create mode 100644 tests/baselines/reference/augmentedTypesModules3.symbols create mode 100644 tests/baselines/reference/augmentedTypesModules3.types create mode 100644 tests/baselines/reference/augmentedTypesVar.symbols create mode 100644 tests/baselines/reference/augmentedTypesVar.types create mode 100644 tests/baselines/reference/autoLift2.symbols create mode 100644 tests/baselines/reference/autoLift2.types create mode 100644 tests/baselines/reference/autolift3.symbols create mode 100644 tests/baselines/reference/autolift3.types create mode 100644 tests/baselines/reference/autolift4.symbols create mode 100644 tests/baselines/reference/autolift4.types create mode 100644 tests/baselines/reference/awaitLiteralValues.symbols create mode 100644 tests/baselines/reference/awaitLiteralValues.types create mode 100644 tests/baselines/reference/await_unaryExpression_es2017_3.symbols create mode 100644 tests/baselines/reference/await_unaryExpression_es2017_3.types create mode 100644 tests/baselines/reference/await_unaryExpression_es6_3.symbols create mode 100644 tests/baselines/reference/await_unaryExpression_es6_3.types create mode 100644 tests/baselines/reference/badArrayIndex.symbols create mode 100644 tests/baselines/reference/badArrayIndex.types create mode 100644 tests/baselines/reference/badArraySyntax.symbols create mode 100644 tests/baselines/reference/badArraySyntax.types create mode 100644 tests/baselines/reference/badExternalModuleReference.symbols create mode 100644 tests/baselines/reference/badExternalModuleReference.types create mode 100644 tests/baselines/reference/baseCheck.symbols create mode 100644 tests/baselines/reference/baseCheck.types create mode 100644 tests/baselines/reference/baseConstraintOfDecorator.symbols create mode 100644 tests/baselines/reference/baseConstraintOfDecorator.types create mode 100644 tests/baselines/reference/baseExpressionTypeParameters.symbols create mode 100644 tests/baselines/reference/baseExpressionTypeParameters.types create mode 100644 tests/baselines/reference/baseTypePrivateMemberClash.symbols create mode 100644 tests/baselines/reference/baseTypePrivateMemberClash.types create mode 100644 tests/baselines/reference/bases.symbols create mode 100644 tests/baselines/reference/bases.types create mode 100644 tests/baselines/reference/binaryArithmatic3.symbols create mode 100644 tests/baselines/reference/binaryArithmatic3.types create mode 100644 tests/baselines/reference/binaryArithmatic4.symbols create mode 100644 tests/baselines/reference/binaryArithmatic4.types create mode 100644 tests/baselines/reference/binaryIntegerLiteralError.symbols create mode 100644 tests/baselines/reference/binaryIntegerLiteralError.types create mode 100644 tests/baselines/reference/bind1.symbols create mode 100644 tests/baselines/reference/bind1.types create mode 100644 tests/baselines/reference/bindingPatternInParameter01.symbols create mode 100644 tests/baselines/reference/bindingPatternInParameter01.types create mode 100644 tests/baselines/reference/bitwiseCompoundAssignmentOperators.symbols create mode 100644 tests/baselines/reference/bitwiseCompoundAssignmentOperators.types create mode 100644 tests/baselines/reference/bitwiseNotOperatorInvalidOperations.symbols create mode 100644 tests/baselines/reference/bitwiseNotOperatorInvalidOperations.types create mode 100644 tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.symbols create mode 100644 tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.types create mode 100644 tests/baselines/reference/blockScopedBindingUsedBeforeDef.symbols create mode 100644 tests/baselines/reference/blockScopedBindingUsedBeforeDef.types create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.symbols create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.types create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.symbols create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.types create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.symbols create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.types create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.symbols create mode 100644 tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.types create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.symbols create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.types create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.symbols create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.types create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.symbols create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.types create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.symbols create mode 100644 tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.types create mode 100644 tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols create mode 100644 tests/baselines/reference/blockScopedVariablesUseBeforeDef.types create mode 100644 tests/baselines/reference/bluebirdStaticThis.symbols create mode 100644 tests/baselines/reference/bluebirdStaticThis.types create mode 100644 tests/baselines/reference/boolInsteadOfBoolean.symbols create mode 100644 tests/baselines/reference/boolInsteadOfBoolean.types create mode 100644 tests/baselines/reference/booleanAssignment.symbols create mode 100644 tests/baselines/reference/booleanAssignment.types create mode 100644 tests/baselines/reference/breakInIterationOrSwitchStatement4.symbols create mode 100644 tests/baselines/reference/breakInIterationOrSwitchStatement4.types create mode 100644 tests/baselines/reference/breakNotInIterationOrSwitchStatement1.symbols create mode 100644 tests/baselines/reference/breakNotInIterationOrSwitchStatement1.types create mode 100644 tests/baselines/reference/breakNotInIterationOrSwitchStatement2.symbols create mode 100644 tests/baselines/reference/breakNotInIterationOrSwitchStatement2.types create mode 100644 tests/baselines/reference/breakTarget5.symbols create mode 100644 tests/baselines/reference/breakTarget5.types create mode 100644 tests/baselines/reference/breakTarget6.symbols create mode 100644 tests/baselines/reference/breakTarget6.types create mode 100644 tests/baselines/reference/cachedModuleResolution6.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution6.types create mode 100644 tests/baselines/reference/cachedModuleResolution7.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution7.types create mode 100644 tests/baselines/reference/cachedModuleResolution8.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution8.types create mode 100644 tests/baselines/reference/cachedModuleResolution9.symbols create mode 100644 tests/baselines/reference/cachedModuleResolution9.types create mode 100644 tests/baselines/reference/callConstructAssignment.symbols create mode 100644 tests/baselines/reference/callConstructAssignment.types create mode 100644 tests/baselines/reference/callExpressionWithMissingTypeArgument1.symbols create mode 100644 tests/baselines/reference/callExpressionWithMissingTypeArgument1.types create mode 100644 tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.symbols create mode 100644 tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.types create mode 100644 tests/baselines/reference/callNonGenericFunctionWithTypeArguments.symbols create mode 100644 tests/baselines/reference/callNonGenericFunctionWithTypeArguments.types create mode 100644 tests/baselines/reference/callOnClass.symbols create mode 100644 tests/baselines/reference/callOnClass.types create mode 100644 tests/baselines/reference/callOnInstance.symbols create mode 100644 tests/baselines/reference/callOnInstance.types create mode 100644 tests/baselines/reference/callOverloadViaElementAccessExpression.symbols create mode 100644 tests/baselines/reference/callOverloadViaElementAccessExpression.types create mode 100644 tests/baselines/reference/callOverloads1.symbols create mode 100644 tests/baselines/reference/callOverloads1.types create mode 100644 tests/baselines/reference/callOverloads2.symbols create mode 100644 tests/baselines/reference/callOverloads2.types create mode 100644 tests/baselines/reference/callOverloads3.symbols create mode 100644 tests/baselines/reference/callOverloads3.types create mode 100644 tests/baselines/reference/callOverloads4.symbols create mode 100644 tests/baselines/reference/callOverloads4.types create mode 100644 tests/baselines/reference/callOverloads5.symbols create mode 100644 tests/baselines/reference/callOverloads5.types create mode 100644 tests/baselines/reference/callSignatureAssignabilityInInheritance.symbols create mode 100644 tests/baselines/reference/callSignatureAssignabilityInInheritance.types create mode 100644 tests/baselines/reference/callSignatureAssignabilityInInheritance3.symbols create mode 100644 tests/baselines/reference/callSignatureAssignabilityInInheritance3.types create mode 100644 tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.symbols create mode 100644 tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.types create mode 100644 tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.symbols create mode 100644 tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.types create mode 100644 tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.symbols create mode 100644 tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.types create mode 100644 tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.symbols create mode 100644 tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.types create mode 100644 tests/baselines/reference/callSignaturesWithDuplicateParameters.symbols create mode 100644 tests/baselines/reference/callSignaturesWithDuplicateParameters.types create mode 100644 tests/baselines/reference/callSignaturesWithParameterInitializers.symbols create mode 100644 tests/baselines/reference/callSignaturesWithParameterInitializers.types create mode 100644 tests/baselines/reference/callSignaturesWithParameterInitializers2.symbols create mode 100644 tests/baselines/reference/callSignaturesWithParameterInitializers2.types create mode 100644 tests/baselines/reference/callWithSpread2.symbols create mode 100644 tests/baselines/reference/callWithSpread2.types create mode 100644 tests/baselines/reference/callWithWrongNumberOfTypeArguments.symbols create mode 100644 tests/baselines/reference/callWithWrongNumberOfTypeArguments.types create mode 100644 tests/baselines/reference/callbackArgsDifferByOptionality.symbols create mode 100644 tests/baselines/reference/callbackArgsDifferByOptionality.types create mode 100644 tests/baselines/reference/cannotInvokeNewOnErrorExpression.symbols create mode 100644 tests/baselines/reference/cannotInvokeNewOnErrorExpression.types create mode 100644 tests/baselines/reference/cannotInvokeNewOnIndexExpression.symbols create mode 100644 tests/baselines/reference/cannotInvokeNewOnIndexExpression.types create mode 100644 tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.symbols create mode 100644 tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.types create mode 100644 tests/baselines/reference/capturedParametersInInitializers2.symbols create mode 100644 tests/baselines/reference/capturedParametersInInitializers2.types create mode 100644 tests/baselines/reference/castOfYield.symbols create mode 100644 tests/baselines/reference/castOfYield.types create mode 100644 tests/baselines/reference/castingTuple.symbols create mode 100644 tests/baselines/reference/castingTuple.types create mode 100644 tests/baselines/reference/catchClauseWithInitializer1.symbols create mode 100644 tests/baselines/reference/catchClauseWithInitializer1.types create mode 100644 tests/baselines/reference/catchClauseWithTypeAnnotation.symbols create mode 100644 tests/baselines/reference/catchClauseWithTypeAnnotation.types create mode 100644 tests/baselines/reference/cf.symbols create mode 100644 tests/baselines/reference/cf.types create mode 100644 tests/baselines/reference/chainedAssignment1.symbols create mode 100644 tests/baselines/reference/chainedAssignment1.types create mode 100644 tests/baselines/reference/chainedAssignment3.symbols create mode 100644 tests/baselines/reference/chainedAssignment3.types create mode 100644 tests/baselines/reference/chainedAssignmentChecking.symbols create mode 100644 tests/baselines/reference/chainedAssignmentChecking.types create mode 100644 tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.symbols create mode 100644 tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types create mode 100644 tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.symbols create mode 100644 tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types create mode 100644 tests/baselines/reference/checkJsFiles.symbols create mode 100644 tests/baselines/reference/checkJsFiles.types create mode 100644 tests/baselines/reference/checkJsFiles2.symbols create mode 100644 tests/baselines/reference/checkJsFiles2.types create mode 100644 tests/baselines/reference/checkJsFiles3.symbols create mode 100644 tests/baselines/reference/checkJsFiles3.types create mode 100644 tests/baselines/reference/checkJsFiles4.symbols create mode 100644 tests/baselines/reference/checkJsFiles4.types create mode 100644 tests/baselines/reference/checkJsFiles_noErrorLocation.symbols create mode 100644 tests/baselines/reference/checkJsFiles_noErrorLocation.types create mode 100644 tests/baselines/reference/checkJsdocTypeTag2.symbols create mode 100644 tests/baselines/reference/checkJsdocTypeTag2.types create mode 100644 tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.symbols create mode 100644 tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.types create mode 100644 tests/baselines/reference/checkJsxChildrenProperty13.symbols create mode 100644 tests/baselines/reference/checkJsxChildrenProperty13.types create mode 100644 tests/baselines/reference/checkJsxChildrenProperty2.symbols create mode 100644 tests/baselines/reference/checkJsxChildrenProperty2.types create mode 100644 tests/baselines/reference/checkJsxChildrenProperty4.symbols create mode 100644 tests/baselines/reference/checkJsxChildrenProperty4.types create mode 100644 tests/baselines/reference/checkJsxChildrenProperty5.symbols create mode 100644 tests/baselines/reference/checkJsxChildrenProperty5.types create mode 100644 tests/baselines/reference/checkJsxChildrenProperty7.symbols create mode 100644 tests/baselines/reference/checkJsxChildrenProperty7.types create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccessing2.symbols create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccessing2.types create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccessing5.symbols create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccessing5.types create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccessing8.symbols create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccessing8.types create mode 100644 tests/baselines/reference/checkTypePredicateForRedundantProperties.symbols create mode 100644 tests/baselines/reference/checkTypePredicateForRedundantProperties.types create mode 100644 tests/baselines/reference/circularImportAlias.symbols create mode 100644 tests/baselines/reference/circularImportAlias.types create mode 100644 tests/baselines/reference/circularIndexedAccessErrors.symbols create mode 100644 tests/baselines/reference/circularIndexedAccessErrors.types create mode 100644 tests/baselines/reference/circularModuleImports.symbols create mode 100644 tests/baselines/reference/circularModuleImports.types create mode 100644 tests/baselines/reference/circularReference.symbols create mode 100644 tests/baselines/reference/circularReference.types create mode 100644 tests/baselines/reference/circularTypeofWithVarOrFunc.symbols create mode 100644 tests/baselines/reference/circularTypeofWithVarOrFunc.types create mode 100644 tests/baselines/reference/class2.symbols create mode 100644 tests/baselines/reference/class2.types create mode 100644 tests/baselines/reference/classAbstractAccessor.symbols create mode 100644 tests/baselines/reference/classAbstractAccessor.types create mode 100644 tests/baselines/reference/classAbstractAssignabilityConstructorFunction.symbols create mode 100644 tests/baselines/reference/classAbstractAssignabilityConstructorFunction.types create mode 100644 tests/baselines/reference/classAbstractClinterfaceAssignability.symbols create mode 100644 tests/baselines/reference/classAbstractClinterfaceAssignability.types create mode 100644 tests/baselines/reference/classAbstractConstructor.symbols create mode 100644 tests/baselines/reference/classAbstractConstructor.types create mode 100644 tests/baselines/reference/classAbstractConstructorAssignability.symbols create mode 100644 tests/baselines/reference/classAbstractConstructorAssignability.types create mode 100644 tests/baselines/reference/classAbstractCrashedOnce.symbols create mode 100644 tests/baselines/reference/classAbstractCrashedOnce.types create mode 100644 tests/baselines/reference/classAbstractDeclarations.d.symbols create mode 100644 tests/baselines/reference/classAbstractDeclarations.d.types create mode 100644 tests/baselines/reference/classAbstractExtends.symbols create mode 100644 tests/baselines/reference/classAbstractExtends.types create mode 100644 tests/baselines/reference/classAbstractFactoryFunction.symbols create mode 100644 tests/baselines/reference/classAbstractFactoryFunction.types create mode 100644 tests/baselines/reference/classAbstractGeneric.symbols create mode 100644 tests/baselines/reference/classAbstractGeneric.types create mode 100644 tests/baselines/reference/classAbstractImportInstantiation.symbols create mode 100644 tests/baselines/reference/classAbstractImportInstantiation.types create mode 100644 tests/baselines/reference/classAbstractInAModule.symbols create mode 100644 tests/baselines/reference/classAbstractInAModule.types create mode 100644 tests/baselines/reference/classAbstractInheritance.symbols create mode 100644 tests/baselines/reference/classAbstractInheritance.types create mode 100644 tests/baselines/reference/classAbstractInstantiations1.symbols create mode 100644 tests/baselines/reference/classAbstractInstantiations1.types create mode 100644 tests/baselines/reference/classAbstractInstantiations2.symbols create mode 100644 tests/baselines/reference/classAbstractInstantiations2.types create mode 100644 tests/baselines/reference/classAbstractManyKeywords.symbols create mode 100644 tests/baselines/reference/classAbstractManyKeywords.types create mode 100644 tests/baselines/reference/classAbstractMergedDeclaration.symbols create mode 100644 tests/baselines/reference/classAbstractMergedDeclaration.types create mode 100644 tests/baselines/reference/classAbstractMethodInNonAbstractClass.symbols create mode 100644 tests/baselines/reference/classAbstractMethodInNonAbstractClass.types create mode 100644 tests/baselines/reference/classAbstractMethodWithImplementation.symbols create mode 100644 tests/baselines/reference/classAbstractMethodWithImplementation.types create mode 100644 tests/baselines/reference/classAbstractMixedWithModifiers.symbols create mode 100644 tests/baselines/reference/classAbstractMixedWithModifiers.types create mode 100644 tests/baselines/reference/classAbstractOverloads.symbols create mode 100644 tests/baselines/reference/classAbstractOverloads.types create mode 100644 tests/baselines/reference/classAbstractOverrideWithAbstract.symbols create mode 100644 tests/baselines/reference/classAbstractOverrideWithAbstract.types create mode 100644 tests/baselines/reference/classAbstractProperties.symbols create mode 100644 tests/baselines/reference/classAbstractProperties.types create mode 100644 tests/baselines/reference/classAbstractSingleLineDecl.symbols create mode 100644 tests/baselines/reference/classAbstractSingleLineDecl.types create mode 100644 tests/baselines/reference/classAbstractSuperCalls.symbols create mode 100644 tests/baselines/reference/classAbstractSuperCalls.types create mode 100644 tests/baselines/reference/classAbstractUsingAbstractMethod1.symbols create mode 100644 tests/baselines/reference/classAbstractUsingAbstractMethod1.types create mode 100644 tests/baselines/reference/classAbstractUsingAbstractMethods2.symbols create mode 100644 tests/baselines/reference/classAbstractUsingAbstractMethods2.types create mode 100644 tests/baselines/reference/classAbstractWithInterface.symbols create mode 100644 tests/baselines/reference/classAbstractWithInterface.types create mode 100644 tests/baselines/reference/classAndInterfaceMergeConflictingMembers.symbols create mode 100644 tests/baselines/reference/classAndInterfaceMergeConflictingMembers.types create mode 100644 tests/baselines/reference/classAndVariableWithSameName.symbols create mode 100644 tests/baselines/reference/classAndVariableWithSameName.types create mode 100644 tests/baselines/reference/classBodyWithStatements.symbols create mode 100644 tests/baselines/reference/classBodyWithStatements.types create mode 100644 tests/baselines/reference/classCannotExtendVar.symbols create mode 100644 tests/baselines/reference/classCannotExtendVar.types create mode 100644 tests/baselines/reference/classConstructorAccessibility.symbols create mode 100644 tests/baselines/reference/classConstructorAccessibility.types create mode 100644 tests/baselines/reference/classConstructorAccessibility2.symbols create mode 100644 tests/baselines/reference/classConstructorAccessibility2.types create mode 100644 tests/baselines/reference/classConstructorAccessibility3.symbols create mode 100644 tests/baselines/reference/classConstructorAccessibility3.types create mode 100644 tests/baselines/reference/classConstructorAccessibility5.symbols create mode 100644 tests/baselines/reference/classConstructorAccessibility5.types create mode 100644 tests/baselines/reference/classConstructorOverloadsAccessibility.symbols create mode 100644 tests/baselines/reference/classConstructorOverloadsAccessibility.types create mode 100644 tests/baselines/reference/classConstructorParametersAccessibility.symbols create mode 100644 tests/baselines/reference/classConstructorParametersAccessibility.types create mode 100644 tests/baselines/reference/classConstructorParametersAccessibility2.symbols create mode 100644 tests/baselines/reference/classConstructorParametersAccessibility2.types create mode 100644 tests/baselines/reference/classExpressionExtendingAbstractClass.symbols create mode 100644 tests/baselines/reference/classExpressionExtendingAbstractClass.types create mode 100644 tests/baselines/reference/classExpressionWithDecorator1.symbols create mode 100644 tests/baselines/reference/classExpressionWithDecorator1.types create mode 100644 tests/baselines/reference/classExtendingClassLikeType.symbols create mode 100644 tests/baselines/reference/classExtendingClassLikeType.types create mode 100644 tests/baselines/reference/classExtendingNonConstructor.symbols create mode 100644 tests/baselines/reference/classExtendingNonConstructor.types create mode 100644 tests/baselines/reference/classExtendingPrimitive.symbols create mode 100644 tests/baselines/reference/classExtendingPrimitive.types create mode 100644 tests/baselines/reference/classExtendingPrimitive2.symbols create mode 100644 tests/baselines/reference/classExtendingPrimitive2.types create mode 100644 tests/baselines/reference/classExtendingQualifiedName.symbols create mode 100644 tests/baselines/reference/classExtendingQualifiedName.types create mode 100644 tests/baselines/reference/classExtendsClauseClassMergedWithModuleNotReferingConstructor.symbols create mode 100644 tests/baselines/reference/classExtendsClauseClassMergedWithModuleNotReferingConstructor.types create mode 100644 tests/baselines/reference/classExtendsClauseClassNotReferringConstructor.symbols create mode 100644 tests/baselines/reference/classExtendsClauseClassNotReferringConstructor.types create mode 100644 tests/baselines/reference/classExtendsEveryObjectType.symbols create mode 100644 tests/baselines/reference/classExtendsEveryObjectType.types create mode 100644 tests/baselines/reference/classExtendsEveryObjectType2.symbols create mode 100644 tests/baselines/reference/classExtendsEveryObjectType2.types create mode 100644 tests/baselines/reference/classExtendsInterface.symbols create mode 100644 tests/baselines/reference/classExtendsInterface.types create mode 100644 tests/baselines/reference/classExtendsInterfaceInExpression.symbols create mode 100644 tests/baselines/reference/classExtendsInterfaceInExpression.types create mode 100644 tests/baselines/reference/classExtendsInterfaceInModule.symbols create mode 100644 tests/baselines/reference/classExtendsInterfaceInModule.types create mode 100644 tests/baselines/reference/classExtendsInterfaceThatExtendsClassWithPrivates1.symbols create mode 100644 tests/baselines/reference/classExtendsInterfaceThatExtendsClassWithPrivates1.types create mode 100644 tests/baselines/reference/classExtendsItself.symbols create mode 100644 tests/baselines/reference/classExtendsItself.types create mode 100644 tests/baselines/reference/classExtendsItselfIndirectly.symbols create mode 100644 tests/baselines/reference/classExtendsItselfIndirectly.types create mode 100644 tests/baselines/reference/classExtendsItselfIndirectly2.symbols create mode 100644 tests/baselines/reference/classExtendsItselfIndirectly2.types create mode 100644 tests/baselines/reference/classExtendsItselfIndirectly3.symbols create mode 100644 tests/baselines/reference/classExtendsItselfIndirectly3.types create mode 100644 tests/baselines/reference/classExtendsMultipleBaseClasses.symbols create mode 100644 tests/baselines/reference/classExtendsMultipleBaseClasses.types create mode 100644 tests/baselines/reference/classExtendsNull.symbols create mode 100644 tests/baselines/reference/classExtendsNull.types create mode 100644 tests/baselines/reference/classExtendsShadowedConstructorFunction.symbols create mode 100644 tests/baselines/reference/classExtendsShadowedConstructorFunction.types create mode 100644 tests/baselines/reference/classExtendsValidConstructorFunction.symbols create mode 100644 tests/baselines/reference/classExtendsValidConstructorFunction.types create mode 100644 tests/baselines/reference/classHeritageWithTrailingSeparator.symbols create mode 100644 tests/baselines/reference/classHeritageWithTrailingSeparator.types create mode 100644 tests/baselines/reference/classImplementsClass2.symbols create mode 100644 tests/baselines/reference/classImplementsClass2.types create mode 100644 tests/baselines/reference/classImplementsClass4.symbols create mode 100644 tests/baselines/reference/classImplementsClass4.types create mode 100644 tests/baselines/reference/classImplementsClass5.symbols create mode 100644 tests/baselines/reference/classImplementsClass5.types create mode 100644 tests/baselines/reference/classImplementsClass6.symbols create mode 100644 tests/baselines/reference/classImplementsClass6.types create mode 100644 tests/baselines/reference/classImplementsMergedClassInterface.symbols create mode 100644 tests/baselines/reference/classImplementsMergedClassInterface.types create mode 100644 tests/baselines/reference/classIndexer2.symbols create mode 100644 tests/baselines/reference/classIndexer2.types create mode 100644 tests/baselines/reference/classIndexer3.symbols create mode 100644 tests/baselines/reference/classIndexer3.types create mode 100644 tests/baselines/reference/classIndexer4.symbols create mode 100644 tests/baselines/reference/classIndexer4.types create mode 100644 tests/baselines/reference/classInheritence.symbols create mode 100644 tests/baselines/reference/classInheritence.types create mode 100644 tests/baselines/reference/classIsSubtypeOfBaseType.symbols create mode 100644 tests/baselines/reference/classIsSubtypeOfBaseType.types create mode 100644 tests/baselines/reference/classMemberInitializerScoping.symbols create mode 100644 tests/baselines/reference/classMemberInitializerScoping.types create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping.symbols create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping.types create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping2.symbols create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping2.types create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping3.symbols create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping3.types create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping4.symbols create mode 100644 tests/baselines/reference/classMemberInitializerWithLamdaScoping4.types create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier.symbols create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier.types create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier2.symbols create mode 100644 tests/baselines/reference/classMemberWithMissingIdentifier2.types create mode 100644 tests/baselines/reference/classOrder2.symbols create mode 100644 tests/baselines/reference/classOrder2.types create mode 100644 tests/baselines/reference/classOverloadForFunction.symbols create mode 100644 tests/baselines/reference/classOverloadForFunction.types create mode 100644 tests/baselines/reference/classOverloadForFunction2.symbols create mode 100644 tests/baselines/reference/classOverloadForFunction2.types create mode 100644 tests/baselines/reference/classPropertyAsPrivate.symbols create mode 100644 tests/baselines/reference/classPropertyAsPrivate.types create mode 100644 tests/baselines/reference/classPropertyAsProtected.symbols create mode 100644 tests/baselines/reference/classPropertyAsProtected.types create mode 100644 tests/baselines/reference/classPropertyIsPublicByDefault.symbols create mode 100644 tests/baselines/reference/classPropertyIsPublicByDefault.types create mode 100644 tests/baselines/reference/classSideInheritance1.symbols create mode 100644 tests/baselines/reference/classSideInheritance1.types create mode 100644 tests/baselines/reference/classSideInheritance2.symbols create mode 100644 tests/baselines/reference/classSideInheritance2.types create mode 100644 tests/baselines/reference/classSideInheritance3.symbols create mode 100644 tests/baselines/reference/classSideInheritance3.types create mode 100644 tests/baselines/reference/classTypeParametersInStatics.symbols create mode 100644 tests/baselines/reference/classTypeParametersInStatics.types create mode 100644 tests/baselines/reference/classUpdateTests.symbols create mode 100644 tests/baselines/reference/classUpdateTests.types create mode 100644 tests/baselines/reference/classWithBaseClassButNoConstructor.symbols create mode 100644 tests/baselines/reference/classWithBaseClassButNoConstructor.types create mode 100644 tests/baselines/reference/classWithConstructors.symbols create mode 100644 tests/baselines/reference/classWithConstructors.types create mode 100644 tests/baselines/reference/classWithDuplicateIdentifier.symbols create mode 100644 tests/baselines/reference/classWithDuplicateIdentifier.types create mode 100644 tests/baselines/reference/classWithEmptyTypeParameter.symbols create mode 100644 tests/baselines/reference/classWithEmptyTypeParameter.types create mode 100644 tests/baselines/reference/classWithMultipleBaseClasses.symbols create mode 100644 tests/baselines/reference/classWithMultipleBaseClasses.types create mode 100644 tests/baselines/reference/classWithOverloadImplementationOfWrongName.symbols create mode 100644 tests/baselines/reference/classWithOverloadImplementationOfWrongName.types create mode 100644 tests/baselines/reference/classWithOverloadImplementationOfWrongName2.symbols create mode 100644 tests/baselines/reference/classWithOverloadImplementationOfWrongName2.types create mode 100644 tests/baselines/reference/classWithPredefinedTypesAsNames.symbols create mode 100644 tests/baselines/reference/classWithPredefinedTypesAsNames.types create mode 100644 tests/baselines/reference/classWithPredefinedTypesAsNames2.symbols create mode 100644 tests/baselines/reference/classWithPredefinedTypesAsNames2.types create mode 100644 tests/baselines/reference/classWithPrivateProperty.symbols create mode 100644 tests/baselines/reference/classWithPrivateProperty.types create mode 100644 tests/baselines/reference/classWithStaticMembers.symbols create mode 100644 tests/baselines/reference/classWithStaticMembers.types create mode 100644 tests/baselines/reference/classWithTwoConstructorDefinitions.symbols create mode 100644 tests/baselines/reference/classWithTwoConstructorDefinitions.types create mode 100644 tests/baselines/reference/classWithoutExplicitConstructor.symbols create mode 100644 tests/baselines/reference/classWithoutExplicitConstructor.types create mode 100644 tests/baselines/reference/cloduleSplitAcrossFiles.symbols create mode 100644 tests/baselines/reference/cloduleSplitAcrossFiles.types create mode 100644 tests/baselines/reference/cloduleStaticMembers.symbols create mode 100644 tests/baselines/reference/cloduleStaticMembers.types create mode 100644 tests/baselines/reference/cloduleTest2.symbols create mode 100644 tests/baselines/reference/cloduleTest2.types create mode 100644 tests/baselines/reference/cloduleWithDuplicateMember1.symbols create mode 100644 tests/baselines/reference/cloduleWithDuplicateMember1.types create mode 100644 tests/baselines/reference/cloduleWithDuplicateMember2.symbols create mode 100644 tests/baselines/reference/cloduleWithDuplicateMember2.types create mode 100644 tests/baselines/reference/cloduleWithPriorInstantiatedModule.symbols create mode 100644 tests/baselines/reference/cloduleWithPriorInstantiatedModule.types create mode 100644 tests/baselines/reference/clodulesDerivedClasses.symbols create mode 100644 tests/baselines/reference/clodulesDerivedClasses.types create mode 100644 tests/baselines/reference/collisionArgumentsArrowFunctions.symbols create mode 100644 tests/baselines/reference/collisionArgumentsArrowFunctions.types create mode 100644 tests/baselines/reference/collisionArgumentsClassConstructor.symbols create mode 100644 tests/baselines/reference/collisionArgumentsClassConstructor.types create mode 100644 tests/baselines/reference/collisionArgumentsClassMethod.symbols create mode 100644 tests/baselines/reference/collisionArgumentsClassMethod.types create mode 100644 tests/baselines/reference/collisionArgumentsFunction.symbols create mode 100644 tests/baselines/reference/collisionArgumentsFunction.types create mode 100644 tests/baselines/reference/collisionArgumentsFunctionExpressions.symbols create mode 100644 tests/baselines/reference/collisionArgumentsFunctionExpressions.types create mode 100644 tests/baselines/reference/collisionCodeGenModuleWithAccessorChildren.symbols create mode 100644 tests/baselines/reference/collisionCodeGenModuleWithAccessorChildren.types create mode 100644 tests/baselines/reference/collisionExportsRequireAndAlias.symbols create mode 100644 tests/baselines/reference/collisionExportsRequireAndAlias.types create mode 100644 tests/baselines/reference/collisionExportsRequireAndClass.symbols create mode 100644 tests/baselines/reference/collisionExportsRequireAndClass.types create mode 100644 tests/baselines/reference/collisionExportsRequireAndEnum.symbols create mode 100644 tests/baselines/reference/collisionExportsRequireAndEnum.types create mode 100644 tests/baselines/reference/collisionExportsRequireAndFunction.symbols create mode 100644 tests/baselines/reference/collisionExportsRequireAndFunction.types create mode 100644 tests/baselines/reference/collisionExportsRequireAndInternalModuleAlias.symbols create mode 100644 tests/baselines/reference/collisionExportsRequireAndInternalModuleAlias.types create mode 100644 tests/baselines/reference/collisionExportsRequireAndModule.symbols create mode 100644 tests/baselines/reference/collisionExportsRequireAndModule.types create mode 100644 tests/baselines/reference/collisionExportsRequireAndVar.symbols create mode 100644 tests/baselines/reference/collisionExportsRequireAndVar.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInAccessors.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInAccessors.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInConstructor.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInConstructor.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInMethod.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInMethod.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInProperty.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalFunctionInProperty.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInAccessors.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInAccessors.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInConstructor.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInConstructor.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInMethod.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInMethod.types create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInProperty.symbols create mode 100644 tests/baselines/reference/collisionSuperAndLocalVarInProperty.types create mode 100644 tests/baselines/reference/collisionSuperAndNameResolution.symbols create mode 100644 tests/baselines/reference/collisionSuperAndNameResolution.types create mode 100644 tests/baselines/reference/collisionSuperAndParameter.symbols create mode 100644 tests/baselines/reference/collisionSuperAndParameter.types create mode 100644 tests/baselines/reference/collisionSuperAndParameter1.symbols create mode 100644 tests/baselines/reference/collisionSuperAndParameter1.types create mode 100644 tests/baselines/reference/collisionSuperAndPropertyNameAsConstuctorParameter.symbols create mode 100644 tests/baselines/reference/collisionSuperAndPropertyNameAsConstuctorParameter.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndAliasInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndAliasInGlobal.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndAmbientClassInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndAmbientClassInGlobal.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndAmbientVarInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndAmbientVarInGlobal.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndClassInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndClassInGlobal.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndEnumInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndEnumInGlobal.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndFunctionInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndFunctionInGlobal.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInAccessors.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInAccessors.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInConstructor.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInConstructor.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInFunction.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInFunction.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInLambda.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInLambda.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInMethod.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInMethod.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInProperty.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarInProperty.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarWithSuperExperssion.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndLocalVarWithSuperExperssion.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndModuleInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndModuleInGlobal.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndNameResolution.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndNameResolution.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndParameter.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndParameter.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndPropertyNameAsConstuctorParameter.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndPropertyNameAsConstuctorParameter.types create mode 100644 tests/baselines/reference/collisionThisExpressionAndVarInGlobal.symbols create mode 100644 tests/baselines/reference/collisionThisExpressionAndVarInGlobal.types create mode 100644 tests/baselines/reference/commaOperatorInvalidAssignmentType.symbols create mode 100644 tests/baselines/reference/commaOperatorInvalidAssignmentType.types create mode 100644 tests/baselines/reference/commaOperatorLeftSideUnused.symbols create mode 100644 tests/baselines/reference/commaOperatorLeftSideUnused.types create mode 100644 tests/baselines/reference/commaOperatorOtherInvalidOperation.symbols create mode 100644 tests/baselines/reference/commaOperatorOtherInvalidOperation.types create mode 100644 tests/baselines/reference/commaOperatorWithoutOperand.symbols create mode 100644 tests/baselines/reference/commaOperatorWithoutOperand.types create mode 100644 tests/baselines/reference/commentOnClassAccessor1.symbols create mode 100644 tests/baselines/reference/commentOnClassAccessor1.types create mode 100644 tests/baselines/reference/commentOnClassAccessor2.symbols create mode 100644 tests/baselines/reference/commentOnClassAccessor2.types create mode 100644 tests/baselines/reference/commentOnImportStatement1.symbols create mode 100644 tests/baselines/reference/commentOnImportStatement1.types create mode 100644 tests/baselines/reference/commentOnImportStatement2.symbols create mode 100644 tests/baselines/reference/commentOnImportStatement2.types create mode 100644 tests/baselines/reference/commentOnImportStatement3.symbols create mode 100644 tests/baselines/reference/commentOnImportStatement3.types create mode 100644 tests/baselines/reference/commentsOnObjectLiteral1.symbols create mode 100644 tests/baselines/reference/commentsOnObjectLiteral1.types create mode 100644 tests/baselines/reference/commentsOnObjectLiteral2.symbols create mode 100644 tests/baselines/reference/commentsOnObjectLiteral2.types create mode 100644 tests/baselines/reference/commonSourceDir2.symbols create mode 100644 tests/baselines/reference/commonSourceDir2.types create mode 100644 tests/baselines/reference/commonSourceDir4.symbols create mode 100644 tests/baselines/reference/commonSourceDir4.types create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnCallSignature.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnCallSignature.types create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnConstructorSignature.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnConstructorSignature.types create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnIndexSignature.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnIndexSignature.types create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnOptionalProperty.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnOptionalProperty.types create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnProperty.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipObjectsOnProperty.types create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipPrimitiveType.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipPrimitiveType.types create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipTypeParameter.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithNoRelationshipTypeParameter.types create mode 100644 tests/baselines/reference/comparisonOperatorWithTypeParameter.symbols create mode 100644 tests/baselines/reference/comparisonOperatorWithTypeParameter.types create mode 100644 tests/baselines/reference/complexClassRelationships.symbols create mode 100644 tests/baselines/reference/complexClassRelationships.types create mode 100644 tests/baselines/reference/complexRecursiveCollections.symbols create mode 100644 tests/baselines/reference/complexRecursiveCollections.types create mode 100644 tests/baselines/reference/complicatedGenericRecursiveBaseClassReference.symbols create mode 100644 tests/baselines/reference/complicatedGenericRecursiveBaseClassReference.types create mode 100644 tests/baselines/reference/complicatedPrivacy.symbols create mode 100644 tests/baselines/reference/complicatedPrivacy.types create mode 100644 tests/baselines/reference/compoundAdditionAssignmentLHSCannotBeAssigned.symbols create mode 100644 tests/baselines/reference/compoundAdditionAssignmentLHSCannotBeAssigned.types create mode 100644 tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.symbols create mode 100644 tests/baselines/reference/compoundAdditionAssignmentWithInvalidOperands.types create mode 100644 tests/baselines/reference/compoundArithmeticAssignmentWithInvalidOperands.symbols create mode 100644 tests/baselines/reference/compoundArithmeticAssignmentWithInvalidOperands.types create mode 100644 tests/baselines/reference/compoundAssignmentLHSIsValue.symbols create mode 100644 tests/baselines/reference/compoundAssignmentLHSIsValue.types create mode 100644 tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.symbols create mode 100644 tests/baselines/reference/compoundExponentiationAssignmentLHSCannotBeAssigned.types create mode 100644 tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.symbols create mode 100644 tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.types create mode 100644 tests/baselines/reference/computedPropertiesInDestructuring1.symbols create mode 100644 tests/baselines/reference/computedPropertiesInDestructuring1.types create mode 100644 tests/baselines/reference/computedPropertiesInDestructuring1_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertiesInDestructuring1_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames12_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames12_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames12_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames12_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames14_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames14_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames14_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames14_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames15_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames15_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames15_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames15_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames17_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames17_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames17_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames17_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames19_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames19_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames19_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames19_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames21_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames21_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames21_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames21_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames23_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames23_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames23_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames23_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames24_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames24_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames24_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames24_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames26_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames26_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames26_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames26_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames27_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames27_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames27_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames27_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames2_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames2_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames2_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames2_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames30_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames30_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames30_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames30_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames32_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames32_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames32_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames32_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames34_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames34_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames34_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames34_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames35_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames35_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames35_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames35_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames36_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames36_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames36_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames36_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames38_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames38_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames38_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames38_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames39_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames39_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames39_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames39_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames3_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames3_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames3_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames3_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames40_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames40_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames40_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames40_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames42_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames42_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames42_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames42_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames43_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames43_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames43_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames43_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames44_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames44_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames44_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames44_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames45_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames45_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames45_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames45_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames49_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames49_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames49_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames49_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames50_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames50_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames50_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames50_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames51_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames51_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames51_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames51_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames5_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames5_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames5_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames5_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames6_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames6_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames6_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames6_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames8_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames8_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames8_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames8_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNames9_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNames9_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNames9_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNames9_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType10_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType10_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType10_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType10_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType8_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType8_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType8_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType8_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType9_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType9_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType9_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesContextualType9_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit3_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit3_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit3_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit3_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit4_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit4_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit4_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesDeclarationEmit4_ES6.types create mode 100644 tests/baselines/reference/computedPropertyNamesOnOverloads_ES5.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesOnOverloads_ES5.types create mode 100644 tests/baselines/reference/computedPropertyNamesOnOverloads_ES6.symbols create mode 100644 tests/baselines/reference/computedPropertyNamesOnOverloads_ES6.types create mode 100644 tests/baselines/reference/concatClassAndString.symbols create mode 100644 tests/baselines/reference/concatClassAndString.types create mode 100644 tests/baselines/reference/conditionalExpression1.symbols create mode 100644 tests/baselines/reference/conditionalExpression1.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine1.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine1.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine10.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine10.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine2.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine2.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine3.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine3.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine4.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine4.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine5.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine5.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine6.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine6.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine7.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine7.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine8.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine8.types create mode 100644 tests/baselines/reference/conditionalExpressionNewLine9.symbols create mode 100644 tests/baselines/reference/conditionalExpressionNewLine9.types create mode 100644 tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.symbols create mode 100644 tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.types create mode 100644 tests/baselines/reference/conflictMarkerDiff3Trivia1.symbols create mode 100644 tests/baselines/reference/conflictMarkerDiff3Trivia1.types create mode 100644 tests/baselines/reference/conflictMarkerDiff3Trivia2.symbols create mode 100644 tests/baselines/reference/conflictMarkerDiff3Trivia2.types create mode 100644 tests/baselines/reference/conflictMarkerTrivia1.symbols create mode 100644 tests/baselines/reference/conflictMarkerTrivia1.types create mode 100644 tests/baselines/reference/conflictMarkerTrivia2.symbols create mode 100644 tests/baselines/reference/conflictMarkerTrivia2.types create mode 100644 tests/baselines/reference/conflictMarkerTrivia3.symbols create mode 100644 tests/baselines/reference/conflictMarkerTrivia3.types create mode 100644 tests/baselines/reference/conflictMarkerTrivia4.symbols create mode 100644 tests/baselines/reference/conflictMarkerTrivia4.types create mode 100644 tests/baselines/reference/conflictingMemberTypesInBases.symbols create mode 100644 tests/baselines/reference/conflictingMemberTypesInBases.types create mode 100644 tests/baselines/reference/conflictingTypeAnnotatedVar.symbols create mode 100644 tests/baselines/reference/conflictingTypeAnnotatedVar.types create mode 100644 tests/baselines/reference/constDeclarationShadowedByVarDeclaration.symbols create mode 100644 tests/baselines/reference/constDeclarationShadowedByVarDeclaration.types create mode 100644 tests/baselines/reference/constDeclarations-access.symbols create mode 100644 tests/baselines/reference/constDeclarations-access.types create mode 100644 tests/baselines/reference/constDeclarations-access2.symbols create mode 100644 tests/baselines/reference/constDeclarations-access2.types create mode 100644 tests/baselines/reference/constDeclarations-access3.symbols create mode 100644 tests/baselines/reference/constDeclarations-access3.types create mode 100644 tests/baselines/reference/constDeclarations-access4.symbols create mode 100644 tests/baselines/reference/constDeclarations-access4.types create mode 100644 tests/baselines/reference/constDeclarations-access5.symbols create mode 100644 tests/baselines/reference/constDeclarations-access5.types create mode 100644 tests/baselines/reference/constDeclarations-ambient-errors.symbols create mode 100644 tests/baselines/reference/constDeclarations-ambient-errors.types create mode 100644 tests/baselines/reference/constDeclarations-errors.symbols create mode 100644 tests/baselines/reference/constDeclarations-errors.types create mode 100644 tests/baselines/reference/constDeclarations-invalidContexts.symbols create mode 100644 tests/baselines/reference/constDeclarations-invalidContexts.types create mode 100644 tests/baselines/reference/constDeclarations-scopes.symbols create mode 100644 tests/baselines/reference/constDeclarations-scopes.types create mode 100644 tests/baselines/reference/constDeclarations-useBeforeDefinition.symbols create mode 100644 tests/baselines/reference/constDeclarations-useBeforeDefinition.types create mode 100644 tests/baselines/reference/constDeclarations-useBeforeDefinition2.symbols create mode 100644 tests/baselines/reference/constDeclarations-useBeforeDefinition2.types create mode 100644 tests/baselines/reference/constDeclarations-validContexts.symbols create mode 100644 tests/baselines/reference/constDeclarations-validContexts.types create mode 100644 tests/baselines/reference/constEnum2.symbols create mode 100644 tests/baselines/reference/constEnum2.types create mode 100644 tests/baselines/reference/constEnumBadPropertyNames.symbols create mode 100644 tests/baselines/reference/constEnumBadPropertyNames.types create mode 100644 tests/baselines/reference/constEnumErrors.symbols create mode 100644 tests/baselines/reference/constEnumErrors.types create mode 100644 tests/baselines/reference/constEnumPropertyAccess2.symbols create mode 100644 tests/baselines/reference/constEnumPropertyAccess2.types create mode 100644 tests/baselines/reference/constraintErrors1.symbols create mode 100644 tests/baselines/reference/constraintErrors1.types create mode 100644 tests/baselines/reference/constraints0.symbols create mode 100644 tests/baselines/reference/constraints0.types create mode 100644 tests/baselines/reference/constructSignatureAssignabilityInInheritance.symbols create mode 100644 tests/baselines/reference/constructSignatureAssignabilityInInheritance.types create mode 100644 tests/baselines/reference/constructSignatureAssignabilityInInheritance3.symbols create mode 100644 tests/baselines/reference/constructSignatureAssignabilityInInheritance3.types create mode 100644 tests/baselines/reference/constructSignatureWithAccessibilityModifiersOnParameters.symbols create mode 100644 tests/baselines/reference/constructSignatureWithAccessibilityModifiersOnParameters.types create mode 100644 tests/baselines/reference/constructSignatureWithAccessibilityModifiersOnParameters2.symbols create mode 100644 tests/baselines/reference/constructSignatureWithAccessibilityModifiersOnParameters2.types create mode 100644 tests/baselines/reference/constructSignaturesWithOverloads2.symbols create mode 100644 tests/baselines/reference/constructSignaturesWithOverloads2.types create mode 100644 tests/baselines/reference/constructorArgsErrors1.symbols create mode 100644 tests/baselines/reference/constructorArgsErrors1.types create mode 100644 tests/baselines/reference/constructorArgsErrors2.symbols create mode 100644 tests/baselines/reference/constructorArgsErrors2.types create mode 100644 tests/baselines/reference/constructorArgsErrors3.symbols create mode 100644 tests/baselines/reference/constructorArgsErrors3.types create mode 100644 tests/baselines/reference/constructorArgsErrors4.symbols create mode 100644 tests/baselines/reference/constructorArgsErrors4.types create mode 100644 tests/baselines/reference/constructorArgsErrors5.symbols create mode 100644 tests/baselines/reference/constructorArgsErrors5.types create mode 100644 tests/baselines/reference/constructorAsType.symbols create mode 100644 tests/baselines/reference/constructorAsType.types create mode 100644 tests/baselines/reference/constructorDefaultValuesReferencingThis.symbols create mode 100644 tests/baselines/reference/constructorDefaultValuesReferencingThis.types create mode 100644 tests/baselines/reference/constructorImplementationWithDefaultValues2.symbols create mode 100644 tests/baselines/reference/constructorImplementationWithDefaultValues2.types create mode 100644 tests/baselines/reference/constructorInvocationWithTooFewTypeArgs.symbols create mode 100644 tests/baselines/reference/constructorInvocationWithTooFewTypeArgs.types create mode 100644 tests/baselines/reference/constructorOverloads1.symbols create mode 100644 tests/baselines/reference/constructorOverloads1.types create mode 100644 tests/baselines/reference/constructorOverloads3.symbols create mode 100644 tests/baselines/reference/constructorOverloads3.types create mode 100644 tests/baselines/reference/constructorOverloads4.symbols create mode 100644 tests/baselines/reference/constructorOverloads4.types create mode 100644 tests/baselines/reference/constructorOverloads5.symbols create mode 100644 tests/baselines/reference/constructorOverloads5.types create mode 100644 tests/baselines/reference/constructorOverloads6.symbols create mode 100644 tests/baselines/reference/constructorOverloads6.types create mode 100644 tests/baselines/reference/constructorOverloads7.symbols create mode 100644 tests/baselines/reference/constructorOverloads7.types create mode 100644 tests/baselines/reference/constructorOverloads8.symbols create mode 100644 tests/baselines/reference/constructorOverloads8.types create mode 100644 tests/baselines/reference/constructorOverloadsWithDefaultValues.symbols create mode 100644 tests/baselines/reference/constructorOverloadsWithDefaultValues.types create mode 100644 tests/baselines/reference/constructorParameterProperties.symbols create mode 100644 tests/baselines/reference/constructorParameterProperties.types create mode 100644 tests/baselines/reference/constructorParameterProperties2.symbols create mode 100644 tests/baselines/reference/constructorParameterProperties2.types create mode 100644 tests/baselines/reference/constructorParameterShadowsOuterScopes.symbols create mode 100644 tests/baselines/reference/constructorParameterShadowsOuterScopes.types create mode 100644 tests/baselines/reference/constructorParametersInVariableDeclarations.symbols create mode 100644 tests/baselines/reference/constructorParametersInVariableDeclarations.types create mode 100644 tests/baselines/reference/constructorParametersThatShadowExternalNamesInVariableDeclarations.symbols create mode 100644 tests/baselines/reference/constructorParametersThatShadowExternalNamesInVariableDeclarations.types create mode 100644 tests/baselines/reference/constructorReturnsInvalidType.symbols create mode 100644 tests/baselines/reference/constructorReturnsInvalidType.types create mode 100644 tests/baselines/reference/constructorStaticParamName.symbols create mode 100644 tests/baselines/reference/constructorStaticParamName.types create mode 100644 tests/baselines/reference/constructorStaticParamNameErrors.symbols create mode 100644 tests/baselines/reference/constructorStaticParamNameErrors.types create mode 100644 tests/baselines/reference/constructorWithAssignableReturnExpression.symbols create mode 100644 tests/baselines/reference/constructorWithAssignableReturnExpression.types create mode 100644 tests/baselines/reference/constructorWithIncompleteTypeAnnotation.symbols create mode 100644 tests/baselines/reference/constructorWithIncompleteTypeAnnotation.types create mode 100644 tests/baselines/reference/constructorsWithSpecializedSignatures.symbols create mode 100644 tests/baselines/reference/constructorsWithSpecializedSignatures.types create mode 100644 tests/baselines/reference/contextualTypeAny.symbols create mode 100644 tests/baselines/reference/contextualTypeAny.types create mode 100644 tests/baselines/reference/contextualTypeWithTuple.symbols create mode 100644 tests/baselines/reference/contextualTypeWithTuple.types create mode 100644 tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.symbols create mode 100644 tests/baselines/reference/contextualTypeWithUnionTypeObjectLiteral.types create mode 100644 tests/baselines/reference/contextualTyping.symbols create mode 100644 tests/baselines/reference/contextualTyping.types create mode 100644 tests/baselines/reference/contextualTyping11.symbols create mode 100644 tests/baselines/reference/contextualTyping11.types create mode 100644 tests/baselines/reference/contextualTyping12.symbols create mode 100644 tests/baselines/reference/contextualTyping12.types create mode 100644 tests/baselines/reference/contextualTyping17.symbols create mode 100644 tests/baselines/reference/contextualTyping17.types create mode 100644 tests/baselines/reference/contextualTyping2.symbols create mode 100644 tests/baselines/reference/contextualTyping2.types create mode 100644 tests/baselines/reference/contextualTyping20.symbols create mode 100644 tests/baselines/reference/contextualTyping20.types create mode 100644 tests/baselines/reference/contextualTyping21.symbols create mode 100644 tests/baselines/reference/contextualTyping21.types create mode 100644 tests/baselines/reference/contextualTyping24.symbols create mode 100644 tests/baselines/reference/contextualTyping24.types create mode 100644 tests/baselines/reference/contextualTyping30.symbols create mode 100644 tests/baselines/reference/contextualTyping30.types create mode 100644 tests/baselines/reference/contextualTyping33.symbols create mode 100644 tests/baselines/reference/contextualTyping33.types create mode 100644 tests/baselines/reference/contextualTyping39.symbols create mode 100644 tests/baselines/reference/contextualTyping39.types create mode 100644 tests/baselines/reference/contextualTyping4.symbols create mode 100644 tests/baselines/reference/contextualTyping4.types create mode 100644 tests/baselines/reference/contextualTyping41.symbols create mode 100644 tests/baselines/reference/contextualTyping41.types create mode 100644 tests/baselines/reference/contextualTyping5.symbols create mode 100644 tests/baselines/reference/contextualTyping5.types create mode 100644 tests/baselines/reference/contextualTyping9.symbols create mode 100644 tests/baselines/reference/contextualTyping9.types create mode 100644 tests/baselines/reference/contextualTypingOfAccessors.symbols create mode 100644 tests/baselines/reference/contextualTypingOfAccessors.types create mode 100644 tests/baselines/reference/contextualTypingOfArrayLiterals1.symbols create mode 100644 tests/baselines/reference/contextualTypingOfArrayLiterals1.types create mode 100644 tests/baselines/reference/contextualTypingOfConditionalExpression2.symbols create mode 100644 tests/baselines/reference/contextualTypingOfConditionalExpression2.types create mode 100644 tests/baselines/reference/contextualTypingOfGenericFunctionTypedArguments1.symbols create mode 100644 tests/baselines/reference/contextualTypingOfGenericFunctionTypedArguments1.types create mode 100644 tests/baselines/reference/contextualTypingOfLambdaReturnExpression.symbols create mode 100644 tests/baselines/reference/contextualTypingOfLambdaReturnExpression.types create mode 100644 tests/baselines/reference/contextualTypingOfObjectLiterals2.symbols create mode 100644 tests/baselines/reference/contextualTypingOfObjectLiterals2.types create mode 100644 tests/baselines/reference/contextualTypingWithFixedTypeParameters1.symbols create mode 100644 tests/baselines/reference/contextualTypingWithFixedTypeParameters1.types create mode 100644 tests/baselines/reference/contextuallyTypeCommaOperator02.symbols create mode 100644 tests/baselines/reference/contextuallyTypeCommaOperator02.types create mode 100644 tests/baselines/reference/contextuallyTypeCommaOperator03.symbols create mode 100644 tests/baselines/reference/contextuallyTypeCommaOperator03.types create mode 100644 tests/baselines/reference/contextuallyTypeLogicalAnd02.symbols create mode 100644 tests/baselines/reference/contextuallyTypeLogicalAnd02.types create mode 100644 tests/baselines/reference/contextuallyTypeLogicalAnd03.symbols create mode 100644 tests/baselines/reference/contextuallyTypeLogicalAnd03.types create mode 100644 tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.symbols create mode 100644 tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.types create mode 100644 tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.symbols create mode 100644 tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration02.types create mode 100644 tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.symbols create mode 100644 tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes01.types create mode 100644 tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.symbols create mode 100644 tests/baselines/reference/contextuallyTypedStringLiteralsInJsxAttributes02.types create mode 100644 tests/baselines/reference/contextuallyTypingRestParameters.symbols create mode 100644 tests/baselines/reference/contextuallyTypingRestParameters.types create mode 100644 tests/baselines/reference/continueInIterationStatement4.symbols create mode 100644 tests/baselines/reference/continueInIterationStatement4.types create mode 100644 tests/baselines/reference/continueNotInIterationStatement1.symbols create mode 100644 tests/baselines/reference/continueNotInIterationStatement1.types create mode 100644 tests/baselines/reference/continueNotInIterationStatement2.symbols create mode 100644 tests/baselines/reference/continueNotInIterationStatement2.types create mode 100644 tests/baselines/reference/continueNotInIterationStatement3.symbols create mode 100644 tests/baselines/reference/continueNotInIterationStatement3.types create mode 100644 tests/baselines/reference/continueNotInIterationStatement4.symbols create mode 100644 tests/baselines/reference/continueNotInIterationStatement4.types create mode 100644 tests/baselines/reference/continueTarget1.symbols create mode 100644 tests/baselines/reference/continueTarget1.types create mode 100644 tests/baselines/reference/continueTarget5.symbols create mode 100644 tests/baselines/reference/continueTarget5.types create mode 100644 tests/baselines/reference/continueTarget6.symbols create mode 100644 tests/baselines/reference/continueTarget6.types create mode 100644 tests/baselines/reference/controlFlowArrayErrors.symbols create mode 100644 tests/baselines/reference/controlFlowArrayErrors.types create mode 100644 tests/baselines/reference/controlFlowIterationErrors.symbols create mode 100644 tests/baselines/reference/controlFlowIterationErrors.types create mode 100644 tests/baselines/reference/controlFlowLoopAnalysis.symbols create mode 100644 tests/baselines/reference/controlFlowLoopAnalysis.types create mode 100644 tests/baselines/reference/controlFlowNoImplicitAny.symbols create mode 100644 tests/baselines/reference/controlFlowNoImplicitAny.types create mode 100644 tests/baselines/reference/controlFlowSelfReferentialLoop.symbols create mode 100644 tests/baselines/reference/controlFlowSelfReferentialLoop.types create mode 100644 tests/baselines/reference/convertKeywordsYes.symbols create mode 100644 tests/baselines/reference/convertKeywordsYes.types create mode 100644 tests/baselines/reference/copyrightWithNewLine1.symbols create mode 100644 tests/baselines/reference/copyrightWithNewLine1.types create mode 100644 tests/baselines/reference/copyrightWithoutNewLine1.symbols create mode 100644 tests/baselines/reference/copyrightWithoutNewLine1.types create mode 100644 tests/baselines/reference/couldNotSelectGenericOverload.symbols create mode 100644 tests/baselines/reference/couldNotSelectGenericOverload.types create mode 100644 tests/baselines/reference/covariantCallbacks.symbols create mode 100644 tests/baselines/reference/covariantCallbacks.types create mode 100644 tests/baselines/reference/crashInsourcePropertyIsRelatableToTargetProperty.symbols create mode 100644 tests/baselines/reference/crashInsourcePropertyIsRelatableToTargetProperty.types create mode 100644 tests/baselines/reference/crashIntypeCheckInvocationExpression.symbols create mode 100644 tests/baselines/reference/crashIntypeCheckInvocationExpression.types create mode 100644 tests/baselines/reference/crashIntypeCheckObjectCreationExpression.symbols create mode 100644 tests/baselines/reference/crashIntypeCheckObjectCreationExpression.types create mode 100644 tests/baselines/reference/crashOnMethodSignatures.symbols create mode 100644 tests/baselines/reference/crashOnMethodSignatures.types create mode 100644 tests/baselines/reference/crashRegressionTest.symbols create mode 100644 tests/baselines/reference/crashRegressionTest.types create mode 100644 tests/baselines/reference/createArray.symbols create mode 100644 tests/baselines/reference/createArray.types create mode 100644 tests/baselines/reference/customEventDetail.symbols create mode 100644 tests/baselines/reference/customEventDetail.types create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.symbols create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorAccessors.types create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.symbols create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorParameterOfFunction.types create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.symbols create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorReturnTypeOfFunction.types create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.symbols create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeAlias.types create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.symbols create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorTypeLiteral.types create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.symbols create mode 100644 tests/baselines/reference/declFileTypeAnnotationVisibilityErrorVariableDeclaration.types create mode 100644 tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.symbols create mode 100644 tests/baselines/reference/declFileWithErrorsInInputDeclarationFile.types create mode 100644 tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.symbols create mode 100644 tests/baselines/reference/declFileWithErrorsInInputDeclarationFileWithOut.types create mode 100644 tests/baselines/reference/declInput-2.symbols create mode 100644 tests/baselines/reference/declInput-2.types create mode 100644 tests/baselines/reference/declarationEmitClassPrivateConstructor2.symbols create mode 100644 tests/baselines/reference/declarationEmitClassPrivateConstructor2.types create mode 100644 tests/baselines/reference/declarationEmitDefaultExport7.symbols create mode 100644 tests/baselines/reference/declarationEmitDefaultExport7.types create mode 100644 tests/baselines/reference/declarationEmitDestructuring2.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuring2.types create mode 100644 tests/baselines/reference/declarationEmitDestructuring4.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuring4.types create mode 100644 tests/baselines/reference/declarationEmitDestructuringArrayPattern2.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuringArrayPattern2.types create mode 100644 tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern.types create mode 100644 tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuringObjectLiteralPattern1.types create mode 100644 tests/baselines/reference/declarationEmitDestructuringParameterProperties.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuringParameterProperties.types create mode 100644 tests/baselines/reference/declarationEmitDestructuringPrivacyError.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuringPrivacyError.types create mode 100644 tests/baselines/reference/declarationEmitDestructuringWithOptionalBindingParameters.symbols create mode 100644 tests/baselines/reference/declarationEmitDestructuringWithOptionalBindingParameters.types create mode 100644 tests/baselines/reference/declarationEmitExpressionInExtends3.symbols create mode 100644 tests/baselines/reference/declarationEmitExpressionInExtends3.types create mode 100644 tests/baselines/reference/declarationEmitExpressionInExtends4.symbols create mode 100644 tests/baselines/reference/declarationEmitExpressionInExtends4.types create mode 100644 tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.symbols create mode 100644 tests/baselines/reference/declarationEmitIdentifierPredicatesWithPrivateName01.types create mode 100644 tests/baselines/reference/declarationEmitIndexTypeNotFound.symbols create mode 100644 tests/baselines/reference/declarationEmitIndexTypeNotFound.types create mode 100644 tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.symbols create mode 100644 tests/baselines/reference/declarationEmitInterfaceWithNonEntityNameExpressionHeritage.types create mode 100644 tests/baselines/reference/declarationEmitInvalidExport.symbols create mode 100644 tests/baselines/reference/declarationEmitInvalidExport.types create mode 100644 tests/baselines/reference/declarationEmitInvalidReference2.symbols create mode 100644 tests/baselines/reference/declarationEmitInvalidReference2.types create mode 100644 tests/baselines/reference/declarationEmitThisPredicates02.symbols create mode 100644 tests/baselines/reference/declarationEmitThisPredicates02.types create mode 100644 tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.symbols create mode 100644 tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName01.types create mode 100644 tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.symbols create mode 100644 tests/baselines/reference/declarationEmitThisPredicatesWithPrivateName02.types create mode 100644 tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.symbols create mode 100644 tests/baselines/reference/declarationEmitTypeAliasTypeParameterExtendingUnknownSymbol.types create mode 100644 tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.symbols create mode 100644 tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.types create mode 100644 tests/baselines/reference/declarationEmitUnknownImport.symbols create mode 100644 tests/baselines/reference/declarationEmitUnknownImport.types create mode 100644 tests/baselines/reference/declarationEmitUnknownImport2.symbols create mode 100644 tests/baselines/reference/declarationEmitUnknownImport2.types create mode 100644 tests/baselines/reference/declarationFileOverwriteError.symbols create mode 100644 tests/baselines/reference/declarationFileOverwriteError.types create mode 100644 tests/baselines/reference/declarationFileOverwriteErrorWithOut.symbols create mode 100644 tests/baselines/reference/declarationFileOverwriteErrorWithOut.types create mode 100644 tests/baselines/reference/declarationFiles.symbols create mode 100644 tests/baselines/reference/declarationFiles.types create mode 100644 tests/baselines/reference/declarationWithNoInitializer.symbols create mode 100644 tests/baselines/reference/declarationWithNoInitializer.types create mode 100644 tests/baselines/reference/declarationsAndAssignments.symbols create mode 100644 tests/baselines/reference/declarationsAndAssignments.types create mode 100644 tests/baselines/reference/declareAlreadySeen.symbols create mode 100644 tests/baselines/reference/declareAlreadySeen.types create mode 100644 tests/baselines/reference/declareClassInterfaceImplementation.symbols create mode 100644 tests/baselines/reference/declareClassInterfaceImplementation.types create mode 100644 tests/baselines/reference/declareModifierOnImport1.symbols create mode 100644 tests/baselines/reference/declareModifierOnImport1.types create mode 100644 tests/baselines/reference/declaredClassMergedwithSelf.symbols create mode 100644 tests/baselines/reference/declaredClassMergedwithSelf.types create mode 100644 tests/baselines/reference/decoratorCallGeneric.symbols create mode 100644 tests/baselines/reference/decoratorCallGeneric.types create mode 100644 tests/baselines/reference/decoratorChecksFunctionBodies.symbols create mode 100644 tests/baselines/reference/decoratorChecksFunctionBodies.types create mode 100644 tests/baselines/reference/decoratorInJsFile.symbols create mode 100644 tests/baselines/reference/decoratorInJsFile.types create mode 100644 tests/baselines/reference/decoratorInJsFile1.symbols create mode 100644 tests/baselines/reference/decoratorInJsFile1.types create mode 100644 tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision4.symbols create mode 100644 tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision4.types create mode 100644 tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision7.symbols create mode 100644 tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision7.types create mode 100644 tests/baselines/reference/decoratorOnArrowFunction.symbols create mode 100644 tests/baselines/reference/decoratorOnArrowFunction.types create mode 100644 tests/baselines/reference/decoratorOnClass3.symbols create mode 100644 tests/baselines/reference/decoratorOnClass3.types create mode 100644 tests/baselines/reference/decoratorOnClass8.symbols create mode 100644 tests/baselines/reference/decoratorOnClass8.types create mode 100644 tests/baselines/reference/decoratorOnClassAccessor3.symbols create mode 100644 tests/baselines/reference/decoratorOnClassAccessor3.types create mode 100644 tests/baselines/reference/decoratorOnClassAccessor6.symbols create mode 100644 tests/baselines/reference/decoratorOnClassAccessor6.types create mode 100644 tests/baselines/reference/decoratorOnClassAccessor7.symbols create mode 100644 tests/baselines/reference/decoratorOnClassAccessor7.types create mode 100644 tests/baselines/reference/decoratorOnClassConstructor1.symbols create mode 100644 tests/baselines/reference/decoratorOnClassConstructor1.types create mode 100644 tests/baselines/reference/decoratorOnClassConstructorParameter4.symbols create mode 100644 tests/baselines/reference/decoratorOnClassConstructorParameter4.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod10.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethod10.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod11.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethod11.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod12.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethod12.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod3.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethod3.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod6.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethod6.types create mode 100644 tests/baselines/reference/decoratorOnClassMethod8.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethod8.types create mode 100644 tests/baselines/reference/decoratorOnClassMethodOverload1.symbols create mode 100644 tests/baselines/reference/decoratorOnClassMethodOverload1.types create mode 100644 tests/baselines/reference/decoratorOnClassProperty11.symbols create mode 100644 tests/baselines/reference/decoratorOnClassProperty11.types create mode 100644 tests/baselines/reference/decoratorOnClassProperty3.symbols create mode 100644 tests/baselines/reference/decoratorOnClassProperty3.types create mode 100644 tests/baselines/reference/decoratorOnClassProperty6.symbols create mode 100644 tests/baselines/reference/decoratorOnClassProperty6.types create mode 100644 tests/baselines/reference/decoratorOnClassProperty7.symbols create mode 100644 tests/baselines/reference/decoratorOnClassProperty7.types create mode 100644 tests/baselines/reference/decoratorOnEnum.symbols create mode 100644 tests/baselines/reference/decoratorOnEnum.types create mode 100644 tests/baselines/reference/decoratorOnEnum2.symbols create mode 100644 tests/baselines/reference/decoratorOnEnum2.types create mode 100644 tests/baselines/reference/decoratorOnFunctionDeclaration.symbols create mode 100644 tests/baselines/reference/decoratorOnFunctionDeclaration.types create mode 100644 tests/baselines/reference/decoratorOnFunctionExpression.symbols create mode 100644 tests/baselines/reference/decoratorOnFunctionExpression.types create mode 100644 tests/baselines/reference/decoratorOnImportEquals1.symbols create mode 100644 tests/baselines/reference/decoratorOnImportEquals1.types create mode 100644 tests/baselines/reference/decoratorOnImportEquals2.symbols create mode 100644 tests/baselines/reference/decoratorOnImportEquals2.types create mode 100644 tests/baselines/reference/decoratorOnInterface.symbols create mode 100644 tests/baselines/reference/decoratorOnInterface.types create mode 100644 tests/baselines/reference/decoratorOnInternalModule.symbols create mode 100644 tests/baselines/reference/decoratorOnInternalModule.types create mode 100644 tests/baselines/reference/decoratorOnTypeAlias.symbols create mode 100644 tests/baselines/reference/decoratorOnTypeAlias.types create mode 100644 tests/baselines/reference/decoratorOnVar.symbols create mode 100644 tests/baselines/reference/decoratorOnVar.types create mode 100644 tests/baselines/reference/decrementAndIncrementOperators.symbols create mode 100644 tests/baselines/reference/decrementAndIncrementOperators.types create mode 100644 tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.symbols create mode 100644 tests/baselines/reference/decrementOperatorWithAnyOtherTypeInvalidOperations.types create mode 100644 tests/baselines/reference/decrementOperatorWithEnumType.symbols create mode 100644 tests/baselines/reference/decrementOperatorWithEnumType.types create mode 100644 tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.symbols create mode 100644 tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.types create mode 100644 tests/baselines/reference/decrementOperatorWithNumberTypeInvalidOperations.symbols create mode 100644 tests/baselines/reference/decrementOperatorWithNumberTypeInvalidOperations.types create mode 100644 tests/baselines/reference/decrementOperatorWithUnsupportedBooleanType.symbols create mode 100644 tests/baselines/reference/decrementOperatorWithUnsupportedBooleanType.types create mode 100644 tests/baselines/reference/decrementOperatorWithUnsupportedStringType.symbols create mode 100644 tests/baselines/reference/decrementOperatorWithUnsupportedStringType.types create mode 100644 tests/baselines/reference/deduplicateImportsInSystem.symbols create mode 100644 tests/baselines/reference/deduplicateImportsInSystem.types create mode 100644 tests/baselines/reference/defaultArgsInFunctionExpressions.symbols create mode 100644 tests/baselines/reference/defaultArgsInFunctionExpressions.types create mode 100644 tests/baselines/reference/defaultArgsInOverloads.symbols create mode 100644 tests/baselines/reference/defaultArgsInOverloads.types create mode 100644 tests/baselines/reference/defaultBestCommonTypesHaveDecls.symbols create mode 100644 tests/baselines/reference/defaultBestCommonTypesHaveDecls.types create mode 100644 tests/baselines/reference/defaultExportsCannotMerge01.symbols create mode 100644 tests/baselines/reference/defaultExportsCannotMerge01.types create mode 100644 tests/baselines/reference/defaultExportsCannotMerge02.symbols create mode 100644 tests/baselines/reference/defaultExportsCannotMerge02.types create mode 100644 tests/baselines/reference/defaultExportsCannotMerge03.symbols create mode 100644 tests/baselines/reference/defaultExportsCannotMerge03.types create mode 100644 tests/baselines/reference/defaultExportsCannotMerge04.symbols create mode 100644 tests/baselines/reference/defaultExportsCannotMerge04.types create mode 100644 tests/baselines/reference/defaultValueInConstructorOverload1.symbols create mode 100644 tests/baselines/reference/defaultValueInConstructorOverload1.types create mode 100644 tests/baselines/reference/defaultValueInFunctionOverload1.symbols create mode 100644 tests/baselines/reference/defaultValueInFunctionOverload1.types create mode 100644 tests/baselines/reference/defaultValueInFunctionTypes.symbols create mode 100644 tests/baselines/reference/defaultValueInFunctionTypes.types create mode 100644 tests/baselines/reference/deferredLookupTypeResolution2.symbols create mode 100644 tests/baselines/reference/deferredLookupTypeResolution2.types create mode 100644 tests/baselines/reference/deleteOperator1.symbols create mode 100644 tests/baselines/reference/deleteOperator1.types create mode 100644 tests/baselines/reference/deleteOperatorInStrictMode.symbols create mode 100644 tests/baselines/reference/deleteOperatorInStrictMode.types create mode 100644 tests/baselines/reference/deleteOperatorInvalidOperations.symbols create mode 100644 tests/baselines/reference/deleteOperatorInvalidOperations.types create mode 100644 tests/baselines/reference/deleteOperatorWithAnyOtherType.symbols create mode 100644 tests/baselines/reference/deleteOperatorWithAnyOtherType.types create mode 100644 tests/baselines/reference/deleteReadonly.symbols create mode 100644 tests/baselines/reference/deleteReadonly.types create mode 100644 tests/baselines/reference/derivedClassConstructorWithoutSuperCall.symbols create mode 100644 tests/baselines/reference/derivedClassConstructorWithoutSuperCall.types create mode 100644 tests/baselines/reference/derivedClassFunctionOverridesBaseClassAccessor.symbols create mode 100644 tests/baselines/reference/derivedClassFunctionOverridesBaseClassAccessor.types create mode 100644 tests/baselines/reference/derivedClassIncludesInheritedMembers.symbols create mode 100644 tests/baselines/reference/derivedClassIncludesInheritedMembers.types create mode 100644 tests/baselines/reference/derivedClassOverridesPrivateFunction1.symbols create mode 100644 tests/baselines/reference/derivedClassOverridesPrivateFunction1.types create mode 100644 tests/baselines/reference/derivedClassOverridesPrivates.symbols create mode 100644 tests/baselines/reference/derivedClassOverridesPrivates.types create mode 100644 tests/baselines/reference/derivedClassOverridesProtectedMembers3.symbols create mode 100644 tests/baselines/reference/derivedClassOverridesProtectedMembers3.types create mode 100644 tests/baselines/reference/derivedClassOverridesProtectedMembers4.symbols create mode 100644 tests/baselines/reference/derivedClassOverridesProtectedMembers4.types create mode 100644 tests/baselines/reference/derivedClassOverridesPublicMembers.symbols create mode 100644 tests/baselines/reference/derivedClassOverridesPublicMembers.types create mode 100644 tests/baselines/reference/derivedClassParameterProperties.symbols create mode 100644 tests/baselines/reference/derivedClassParameterProperties.types create mode 100644 tests/baselines/reference/derivedClassSuperCallsInNonConstructorMembers.symbols create mode 100644 tests/baselines/reference/derivedClassSuperCallsInNonConstructorMembers.types create mode 100644 tests/baselines/reference/derivedClassSuperCallsWithThisArg.symbols create mode 100644 tests/baselines/reference/derivedClassSuperCallsWithThisArg.types create mode 100644 tests/baselines/reference/derivedClassTransitivity.symbols create mode 100644 tests/baselines/reference/derivedClassTransitivity.types create mode 100644 tests/baselines/reference/derivedClassTransitivity2.symbols create mode 100644 tests/baselines/reference/derivedClassTransitivity2.types create mode 100644 tests/baselines/reference/derivedClassTransitivity3.symbols create mode 100644 tests/baselines/reference/derivedClassTransitivity3.types create mode 100644 tests/baselines/reference/derivedClassTransitivity4.symbols create mode 100644 tests/baselines/reference/derivedClassTransitivity4.types create mode 100644 tests/baselines/reference/derivedClassWithAny.symbols create mode 100644 tests/baselines/reference/derivedClassWithAny.types create mode 100644 tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.symbols create mode 100644 tests/baselines/reference/derivedClassWithPrivateInstanceShadowingProtectedInstance.types create mode 100644 tests/baselines/reference/derivedClassWithPrivateInstanceShadowingPublicInstance.symbols create mode 100644 tests/baselines/reference/derivedClassWithPrivateInstanceShadowingPublicInstance.types create mode 100644 tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.symbols create mode 100644 tests/baselines/reference/derivedClassWithPrivateStaticShadowingProtectedStatic.types create mode 100644 tests/baselines/reference/derivedClassWithPrivateStaticShadowingPublicStatic.symbols create mode 100644 tests/baselines/reference/derivedClassWithPrivateStaticShadowingPublicStatic.types create mode 100644 tests/baselines/reference/derivedClassWithoutExplicitConstructor.symbols create mode 100644 tests/baselines/reference/derivedClassWithoutExplicitConstructor.types create mode 100644 tests/baselines/reference/derivedClassWithoutExplicitConstructor2.symbols create mode 100644 tests/baselines/reference/derivedClassWithoutExplicitConstructor2.types create mode 100644 tests/baselines/reference/derivedClassWithoutExplicitConstructor3.symbols create mode 100644 tests/baselines/reference/derivedClassWithoutExplicitConstructor3.types create mode 100644 tests/baselines/reference/derivedClasses.symbols create mode 100644 tests/baselines/reference/derivedClasses.types create mode 100644 tests/baselines/reference/derivedGenericClassWithAny.symbols create mode 100644 tests/baselines/reference/derivedGenericClassWithAny.types create mode 100644 tests/baselines/reference/derivedInterfaceCallSignature.symbols create mode 100644 tests/baselines/reference/derivedInterfaceCallSignature.types create mode 100644 tests/baselines/reference/derivedInterfaceIncompatibleWithBaseIndexer.symbols create mode 100644 tests/baselines/reference/derivedInterfaceIncompatibleWithBaseIndexer.types create mode 100644 tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.symbols create mode 100644 tests/baselines/reference/derivedTypeAccessesHiddenBaseCallViaSuperPropertyAccess.types create mode 100644 tests/baselines/reference/derivedTypeCallingBaseImplWithOptionalParams.symbols create mode 100644 tests/baselines/reference/derivedTypeCallingBaseImplWithOptionalParams.types create mode 100644 tests/baselines/reference/derivedTypeIncompatibleSignatures.symbols create mode 100644 tests/baselines/reference/derivedTypeIncompatibleSignatures.types create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5.symbols create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5.types create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.symbols create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5iterable.types create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.symbols create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.types create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.symbols create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.types create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.symbols create mode 100644 tests/baselines/reference/destructuringArrayBindingPatternAndAssignment3.types create mode 100644 tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.symbols create mode 100644 tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.types create mode 100644 tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.symbols create mode 100644 tests/baselines/reference/destructuringObjectBindingPatternAndAssignment4.types create mode 100644 tests/baselines/reference/destructuringParameterDeclaration1ES5.symbols create mode 100644 tests/baselines/reference/destructuringParameterDeclaration1ES5.types create mode 100644 tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.symbols create mode 100644 tests/baselines/reference/destructuringParameterDeclaration1ES5iterable.types create mode 100644 tests/baselines/reference/destructuringParameterDeclaration1ES6.symbols create mode 100644 tests/baselines/reference/destructuringParameterDeclaration1ES6.types create mode 100644 tests/baselines/reference/destructuringParameterDeclaration2.symbols create mode 100644 tests/baselines/reference/destructuringParameterDeclaration2.types create mode 100644 tests/baselines/reference/destructuringParameterDeclaration4.symbols create mode 100644 tests/baselines/reference/destructuringParameterDeclaration4.types create mode 100644 tests/baselines/reference/destructuringParameterDeclaration5.symbols create mode 100644 tests/baselines/reference/destructuringParameterDeclaration5.types create mode 100644 tests/baselines/reference/destructuringParameterDeclaration6.symbols create mode 100644 tests/baselines/reference/destructuringParameterDeclaration6.types create mode 100644 tests/baselines/reference/destructuringParameterProperties1.symbols create mode 100644 tests/baselines/reference/destructuringParameterProperties1.types create mode 100644 tests/baselines/reference/destructuringParameterProperties2.symbols create mode 100644 tests/baselines/reference/destructuringParameterProperties2.types create mode 100644 tests/baselines/reference/destructuringParameterProperties3.symbols create mode 100644 tests/baselines/reference/destructuringParameterProperties3.types create mode 100644 tests/baselines/reference/destructuringParameterProperties4.symbols create mode 100644 tests/baselines/reference/destructuringParameterProperties4.types create mode 100644 tests/baselines/reference/destructuringParameterProperties5.symbols create mode 100644 tests/baselines/reference/destructuringParameterProperties5.types create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_1.symbols create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_1.types create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_2.symbols create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_2.types create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_3.symbols create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_3.types create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_4.symbols create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_4.types create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_6.symbols create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_6.types create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_7.symbols create mode 100644 tests/baselines/reference/destructuringTypeAssertionsES5_7.types create mode 100644 tests/baselines/reference/destructuringVariableDeclaration2.symbols create mode 100644 tests/baselines/reference/destructuringVariableDeclaration2.types create mode 100644 tests/baselines/reference/detachedCommentAtStartOfFunctionBody1.symbols create mode 100644 tests/baselines/reference/detachedCommentAtStartOfFunctionBody1.types create mode 100644 tests/baselines/reference/detachedCommentAtStartOfFunctionBody2.symbols create mode 100644 tests/baselines/reference/detachedCommentAtStartOfFunctionBody2.types create mode 100644 tests/baselines/reference/differentTypesWithSameName.symbols create mode 100644 tests/baselines/reference/differentTypesWithSameName.types create mode 100644 tests/baselines/reference/directDependenceBetweenTypeAliases.symbols create mode 100644 tests/baselines/reference/directDependenceBetweenTypeAliases.types create mode 100644 tests/baselines/reference/directReferenceToNull.symbols create mode 100644 tests/baselines/reference/directReferenceToNull.types create mode 100644 tests/baselines/reference/directReferenceToUndefined.symbols create mode 100644 tests/baselines/reference/directReferenceToUndefined.types create mode 100644 tests/baselines/reference/disallowLineTerminatorBeforeArrow.symbols create mode 100644 tests/baselines/reference/disallowLineTerminatorBeforeArrow.types create mode 100644 tests/baselines/reference/discriminantPropertyCheck.symbols create mode 100644 tests/baselines/reference/discriminantPropertyCheck.types create mode 100644 tests/baselines/reference/discriminatedUnionErrorMessage.symbols create mode 100644 tests/baselines/reference/discriminatedUnionErrorMessage.types create mode 100644 tests/baselines/reference/discriminatedUnionTypes1.symbols create mode 100644 tests/baselines/reference/discriminatedUnionTypes1.types create mode 100644 tests/baselines/reference/dontShowCompilerGeneratedMembers.symbols create mode 100644 tests/baselines/reference/dontShowCompilerGeneratedMembers.types create mode 100644 tests/baselines/reference/dottedModuleName.symbols create mode 100644 tests/baselines/reference/dottedModuleName.types create mode 100644 tests/baselines/reference/doubleUnderStringLiteralAssignability.symbols create mode 100644 tests/baselines/reference/doubleUnderStringLiteralAssignability.types create mode 100644 tests/baselines/reference/doubleUnderscoreExportStarConflict.symbols create mode 100644 tests/baselines/reference/doubleUnderscoreExportStarConflict.types create mode 100644 tests/baselines/reference/downlevelLetConst1.symbols create mode 100644 tests/baselines/reference/downlevelLetConst1.types create mode 100644 tests/baselines/reference/downlevelLetConst11.symbols create mode 100644 tests/baselines/reference/downlevelLetConst11.types create mode 100644 tests/baselines/reference/downlevelLetConst12.symbols create mode 100644 tests/baselines/reference/downlevelLetConst12.types create mode 100644 tests/baselines/reference/downlevelLetConst16.symbols create mode 100644 tests/baselines/reference/downlevelLetConst16.types create mode 100644 tests/baselines/reference/downlevelLetConst18.symbols create mode 100644 tests/baselines/reference/downlevelLetConst18.types create mode 100644 tests/baselines/reference/downlevelLetConst19.symbols create mode 100644 tests/baselines/reference/downlevelLetConst19.types create mode 100644 tests/baselines/reference/downlevelLetConst2.symbols create mode 100644 tests/baselines/reference/downlevelLetConst2.types create mode 100644 tests/baselines/reference/downlevelLetConst4.symbols create mode 100644 tests/baselines/reference/downlevelLetConst4.types create mode 100644 tests/baselines/reference/downlevelLetConst6.symbols create mode 100644 tests/baselines/reference/downlevelLetConst6.types create mode 100644 tests/baselines/reference/duplicateClassElements.symbols create mode 100644 tests/baselines/reference/duplicateClassElements.types create mode 100644 tests/baselines/reference/duplicateExportAssignments.symbols create mode 100644 tests/baselines/reference/duplicateExportAssignments.types create mode 100644 tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.symbols create mode 100644 tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration1.types create mode 100644 tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.symbols create mode 100644 tests/baselines/reference/duplicateIdentifierBindingElementInParameterDeclaration2.types create mode 100644 tests/baselines/reference/duplicateIdentifierComputedName.symbols create mode 100644 tests/baselines/reference/duplicateIdentifierComputedName.types create mode 100644 tests/baselines/reference/duplicateIdentifierDifferentModifiers.symbols create mode 100644 tests/baselines/reference/duplicateIdentifierDifferentModifiers.types create mode 100644 tests/baselines/reference/duplicateIdentifierDifferentSpelling.symbols create mode 100644 tests/baselines/reference/duplicateIdentifierDifferentSpelling.types create mode 100644 tests/baselines/reference/duplicateIdentifierInCatchBlock.symbols create mode 100644 tests/baselines/reference/duplicateIdentifierInCatchBlock.types create mode 100644 tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.symbols create mode 100644 tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.types create mode 100644 tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.symbols create mode 100644 tests/baselines/reference/duplicateIdentifiersAcrossFileBoundaries.types create mode 100644 tests/baselines/reference/duplicateInterfaceMembers1.symbols create mode 100644 tests/baselines/reference/duplicateInterfaceMembers1.types create mode 100644 tests/baselines/reference/duplicateLabel1.symbols create mode 100644 tests/baselines/reference/duplicateLabel1.types create mode 100644 tests/baselines/reference/duplicateLabel2.symbols create mode 100644 tests/baselines/reference/duplicateLabel2.types create mode 100644 tests/baselines/reference/duplicateLocalVariable1.symbols create mode 100644 tests/baselines/reference/duplicateLocalVariable1.types create mode 100644 tests/baselines/reference/duplicateLocalVariable2.symbols create mode 100644 tests/baselines/reference/duplicateLocalVariable2.types create mode 100644 tests/baselines/reference/duplicateLocalVariable3.symbols create mode 100644 tests/baselines/reference/duplicateLocalVariable3.types create mode 100644 tests/baselines/reference/duplicateLocalVariable4.symbols create mode 100644 tests/baselines/reference/duplicateLocalVariable4.types create mode 100644 tests/baselines/reference/duplicateNumericIndexers.symbols create mode 100644 tests/baselines/reference/duplicateNumericIndexers.types create mode 100644 tests/baselines/reference/duplicateObjectLiteralProperty.symbols create mode 100644 tests/baselines/reference/duplicateObjectLiteralProperty.types create mode 100644 tests/baselines/reference/duplicatePackage.symbols create mode 100644 tests/baselines/reference/duplicatePackage.types create mode 100644 tests/baselines/reference/duplicatePackage_withErrors.symbols create mode 100644 tests/baselines/reference/duplicatePackage_withErrors.types create mode 100644 tests/baselines/reference/duplicatePropertiesInStrictMode.symbols create mode 100644 tests/baselines/reference/duplicatePropertiesInStrictMode.types create mode 100644 tests/baselines/reference/duplicatePropertiesInTypeAssertions01.symbols create mode 100644 tests/baselines/reference/duplicatePropertiesInTypeAssertions01.types create mode 100644 tests/baselines/reference/duplicatePropertiesInTypeAssertions02.symbols create mode 100644 tests/baselines/reference/duplicatePropertiesInTypeAssertions02.types create mode 100644 tests/baselines/reference/duplicatePropertyNames.symbols create mode 100644 tests/baselines/reference/duplicatePropertyNames.types create mode 100644 tests/baselines/reference/duplicateStringIndexers.symbols create mode 100644 tests/baselines/reference/duplicateStringIndexers.types create mode 100644 tests/baselines/reference/duplicateStringNamedProperty1.symbols create mode 100644 tests/baselines/reference/duplicateStringNamedProperty1.types create mode 100644 tests/baselines/reference/duplicateSymbolsExportMatching.symbols create mode 100644 tests/baselines/reference/duplicateSymbolsExportMatching.types create mode 100644 tests/baselines/reference/duplicateTypeParameters1.symbols create mode 100644 tests/baselines/reference/duplicateTypeParameters1.types create mode 100644 tests/baselines/reference/duplicateTypeParameters2.symbols create mode 100644 tests/baselines/reference/duplicateTypeParameters2.types create mode 100644 tests/baselines/reference/duplicateTypeParameters3.symbols create mode 100644 tests/baselines/reference/duplicateTypeParameters3.types create mode 100644 tests/baselines/reference/duplicateVarAndImport2.symbols create mode 100644 tests/baselines/reference/duplicateVarAndImport2.types create mode 100644 tests/baselines/reference/duplicateVariablesWithAny.symbols create mode 100644 tests/baselines/reference/duplicateVariablesWithAny.types create mode 100644 tests/baselines/reference/duplicateVarsAcrossFileBoundaries.symbols create mode 100644 tests/baselines/reference/duplicateVarsAcrossFileBoundaries.types create mode 100644 tests/baselines/reference/elaboratedErrors.symbols create mode 100644 tests/baselines/reference/elaboratedErrors.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments01.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments02.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments03.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments04.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments05.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments06.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments07.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments09.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments10.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments11.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments12.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments12_ES6.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments14.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments15.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments16.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments17.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments18.types create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.symbols create mode 100644 tests/baselines/reference/emitArrowFunctionWhenUsingArguments19.types create mode 100644 tests/baselines/reference/emitCapturingThisInTupleDestructuring1.symbols create mode 100644 tests/baselines/reference/emitCapturingThisInTupleDestructuring1.types create mode 100644 tests/baselines/reference/emitCapturingThisInTupleDestructuring2.symbols create mode 100644 tests/baselines/reference/emitCapturingThisInTupleDestructuring2.types create mode 100644 tests/baselines/reference/emitClassExpressionInDeclarationFile2.symbols create mode 100644 tests/baselines/reference/emitClassExpressionInDeclarationFile2.types create mode 100644 tests/baselines/reference/emitThisInSuperMethodCall.symbols create mode 100644 tests/baselines/reference/emitThisInSuperMethodCall.types create mode 100644 tests/baselines/reference/emptyGenericParamList.symbols create mode 100644 tests/baselines/reference/emptyGenericParamList.types create mode 100644 tests/baselines/reference/emptyMemberAccess.symbols create mode 100644 tests/baselines/reference/emptyMemberAccess.types create mode 100644 tests/baselines/reference/emptyModuleName.symbols create mode 100644 tests/baselines/reference/emptyModuleName.types create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter04.symbols create mode 100644 tests/baselines/reference/emptyObjectBindingPatternParameter04.types create mode 100644 tests/baselines/reference/emptyThenWarning.symbols create mode 100644 tests/baselines/reference/emptyThenWarning.types create mode 100644 tests/baselines/reference/emptyTuplesTypeAssertion01.symbols create mode 100644 tests/baselines/reference/emptyTuplesTypeAssertion01.types create mode 100644 tests/baselines/reference/emptyTuplesTypeAssertion02.symbols create mode 100644 tests/baselines/reference/emptyTuplesTypeAssertion02.types create mode 100644 tests/baselines/reference/emptyTypeArgumentList.symbols create mode 100644 tests/baselines/reference/emptyTypeArgumentList.types create mode 100644 tests/baselines/reference/emptyTypeArgumentListWithNew.symbols create mode 100644 tests/baselines/reference/emptyTypeArgumentListWithNew.types create mode 100644 tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.symbols create mode 100644 tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5.types create mode 100644 tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.symbols create mode 100644 tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES5iterable.types create mode 100644 tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.symbols create mode 100644 tests/baselines/reference/emptyVariableDeclarationBindingPatterns02_ES6.types create mode 100644 tests/baselines/reference/enumAssignability.symbols create mode 100644 tests/baselines/reference/enumAssignability.types create mode 100644 tests/baselines/reference/enumAssignabilityInInheritance.symbols create mode 100644 tests/baselines/reference/enumAssignabilityInInheritance.types create mode 100644 tests/baselines/reference/enumAssignmentCompat.symbols create mode 100644 tests/baselines/reference/enumAssignmentCompat.types create mode 100644 tests/baselines/reference/enumAssignmentCompat2.symbols create mode 100644 tests/baselines/reference/enumAssignmentCompat2.types create mode 100644 tests/baselines/reference/enumAssignmentCompat3.symbols create mode 100644 tests/baselines/reference/enumAssignmentCompat3.types create mode 100644 tests/baselines/reference/enumAssignmentCompat5.symbols create mode 100644 tests/baselines/reference/enumAssignmentCompat5.types create mode 100644 tests/baselines/reference/enumBasics1.symbols create mode 100644 tests/baselines/reference/enumBasics1.types create mode 100644 tests/baselines/reference/enumConflictsWithGlobalIdentifier.symbols create mode 100644 tests/baselines/reference/enumConflictsWithGlobalIdentifier.types create mode 100644 tests/baselines/reference/enumErrors.symbols create mode 100644 tests/baselines/reference/enumErrors.types create mode 100644 tests/baselines/reference/enumGenericTypeClash.symbols create mode 100644 tests/baselines/reference/enumGenericTypeClash.types create mode 100644 tests/baselines/reference/enumIdentifierLiterals.symbols create mode 100644 tests/baselines/reference/enumIdentifierLiterals.types create mode 100644 tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.symbols create mode 100644 tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.types create mode 100644 tests/baselines/reference/enumLiteralAssignableToEnumInsideUnion.symbols create mode 100644 tests/baselines/reference/enumLiteralAssignableToEnumInsideUnion.types create mode 100644 tests/baselines/reference/enumLiteralTypes3.symbols create mode 100644 tests/baselines/reference/enumLiteralTypes3.types create mode 100644 tests/baselines/reference/enumMemberResolution.symbols create mode 100644 tests/baselines/reference/enumMemberResolution.types create mode 100644 tests/baselines/reference/enumMergingErrors.symbols create mode 100644 tests/baselines/reference/enumMergingErrors.types create mode 100644 tests/baselines/reference/enumPropertyAccess.symbols create mode 100644 tests/baselines/reference/enumPropertyAccess.types create mode 100644 tests/baselines/reference/enumUsedBeforeDeclaration.symbols create mode 100644 tests/baselines/reference/enumUsedBeforeDeclaration.types create mode 100644 tests/baselines/reference/enumWithComputedMember.symbols create mode 100644 tests/baselines/reference/enumWithComputedMember.types create mode 100644 tests/baselines/reference/enumWithParenthesizedInitializer1.symbols create mode 100644 tests/baselines/reference/enumWithParenthesizedInitializer1.types create mode 100644 tests/baselines/reference/enumWithPrimitiveName.symbols create mode 100644 tests/baselines/reference/enumWithPrimitiveName.types create mode 100644 tests/baselines/reference/enumsWithMultipleDeclarations1.symbols create mode 100644 tests/baselines/reference/enumsWithMultipleDeclarations1.types create mode 100644 tests/baselines/reference/enumsWithMultipleDeclarations2.symbols create mode 100644 tests/baselines/reference/enumsWithMultipleDeclarations2.types create mode 100644 tests/baselines/reference/equalityStrictNulls.symbols create mode 100644 tests/baselines/reference/equalityStrictNulls.types create mode 100644 tests/baselines/reference/equalityWithIntersectionTypes01.symbols create mode 100644 tests/baselines/reference/equalityWithIntersectionTypes01.types create mode 100644 tests/baselines/reference/errorElaboration.symbols create mode 100644 tests/baselines/reference/errorElaboration.types create mode 100644 tests/baselines/reference/errorForConflictingExportEqualsValue.symbols create mode 100644 tests/baselines/reference/errorForConflictingExportEqualsValue.types create mode 100644 tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.symbols create mode 100644 tests/baselines/reference/errorForUsingPropertyOfTypeAsType01.types create mode 100644 tests/baselines/reference/errorForwardReferenceForwadingConstructor.symbols create mode 100644 tests/baselines/reference/errorForwardReferenceForwadingConstructor.types create mode 100644 tests/baselines/reference/errorHandlingInInstanceOf.symbols create mode 100644 tests/baselines/reference/errorHandlingInInstanceOf.types create mode 100644 tests/baselines/reference/errorLocationForInterfaceExtension.symbols create mode 100644 tests/baselines/reference/errorLocationForInterfaceExtension.types create mode 100644 tests/baselines/reference/errorMessageOnObjectLiteralType.symbols create mode 100644 tests/baselines/reference/errorMessageOnObjectLiteralType.types create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes01.symbols create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes01.types create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes02.symbols create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes02.types create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes03.symbols create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes03.types create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes04.symbols create mode 100644 tests/baselines/reference/errorMessagesIntersectionTypes04.types create mode 100644 tests/baselines/reference/errorOnContextuallyTypedReturnType.symbols create mode 100644 tests/baselines/reference/errorOnContextuallyTypedReturnType.types create mode 100644 tests/baselines/reference/errorOnInitializerInInterfaceProperty.symbols create mode 100644 tests/baselines/reference/errorOnInitializerInInterfaceProperty.types create mode 100644 tests/baselines/reference/errorOnInitializerInObjectTypeLiteralProperty.symbols create mode 100644 tests/baselines/reference/errorOnInitializerInObjectTypeLiteralProperty.types create mode 100644 tests/baselines/reference/errorRecoveryInClassDeclaration.symbols create mode 100644 tests/baselines/reference/errorRecoveryInClassDeclaration.types create mode 100644 tests/baselines/reference/errorRecoveryWithDotFollowedByNamespaceKeyword.symbols create mode 100644 tests/baselines/reference/errorRecoveryWithDotFollowedByNamespaceKeyword.types create mode 100644 tests/baselines/reference/errorSuperCalls.symbols create mode 100644 tests/baselines/reference/errorSuperCalls.types create mode 100644 tests/baselines/reference/errorSuperPropertyAccess.symbols create mode 100644 tests/baselines/reference/errorSuperPropertyAccess.types create mode 100644 tests/baselines/reference/errorSupression1.symbols create mode 100644 tests/baselines/reference/errorSupression1.types create mode 100644 tests/baselines/reference/errorTypesAsTypeArguments.symbols create mode 100644 tests/baselines/reference/errorTypesAsTypeArguments.types create mode 100644 tests/baselines/reference/errorWithTruncatedType.symbols create mode 100644 tests/baselines/reference/errorWithTruncatedType.types create mode 100644 tests/baselines/reference/errorsInGenericTypeReference.symbols create mode 100644 tests/baselines/reference/errorsInGenericTypeReference.types create mode 100644 tests/baselines/reference/errorsOnImportedSymbol.symbols create mode 100644 tests/baselines/reference/errorsOnImportedSymbol.types create mode 100644 tests/baselines/reference/es3-oldStyleOctalLiteralInEnums.symbols create mode 100644 tests/baselines/reference/es3-oldStyleOctalLiteralInEnums.types create mode 100644 tests/baselines/reference/es3-oldStyleOctalLiteralTypes.symbols create mode 100644 tests/baselines/reference/es3-oldStyleOctalLiteralTypes.types create mode 100644 tests/baselines/reference/es5-asyncFunctionWithStatements.symbols create mode 100644 tests/baselines/reference/es5-asyncFunctionWithStatements.types create mode 100644 tests/baselines/reference/es5-oldStyleOctalLiteralInEnums.symbols create mode 100644 tests/baselines/reference/es5-oldStyleOctalLiteralInEnums.types create mode 100644 tests/baselines/reference/es5ExportEquals.symbols create mode 100644 tests/baselines/reference/es5ExportEquals.types create mode 100644 tests/baselines/reference/es5ModuleInternalNamedImports.symbols create mode 100644 tests/baselines/reference/es5ModuleInternalNamedImports.types create mode 100644 tests/baselines/reference/es6ClassTest.symbols create mode 100644 tests/baselines/reference/es6ClassTest.types create mode 100644 tests/baselines/reference/es6ClassTest2.symbols create mode 100644 tests/baselines/reference/es6ClassTest2.types create mode 100644 tests/baselines/reference/es6ClassTest9.symbols create mode 100644 tests/baselines/reference/es6ClassTest9.types create mode 100644 tests/baselines/reference/es6DeclOrdering.symbols create mode 100644 tests/baselines/reference/es6DeclOrdering.types create mode 100644 tests/baselines/reference/es6ExportAssignment.symbols create mode 100644 tests/baselines/reference/es6ExportAssignment.types create mode 100644 tests/baselines/reference/es6ExportAssignment2.symbols create mode 100644 tests/baselines/reference/es6ExportAssignment2.types create mode 100644 tests/baselines/reference/es6ExportEquals.symbols create mode 100644 tests/baselines/reference/es6ExportEquals.types create mode 100644 tests/baselines/reference/es6ExportEqualsInterop.symbols create mode 100644 tests/baselines/reference/es6ExportEqualsInterop.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1InEs5.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport1WithExport.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportDts1.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportInEs5.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImportWithExport.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBinding1WithExport.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingDts.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingInEs5.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamespaceBindingWithExport.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingInEs5.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingInEs5.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingMergeErrors.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingMergeErrors.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingNoDefaultProperty.types create mode 100644 tests/baselines/reference/es6ImportDefaultBindingWithExport.symbols create mode 100644 tests/baselines/reference/es6ImportDefaultBindingWithExport.types create mode 100644 tests/baselines/reference/es6ImportEqualsDeclaration.symbols create mode 100644 tests/baselines/reference/es6ImportEqualsDeclaration.types create mode 100644 tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.symbols create mode 100644 tests/baselines/reference/es6ImportNameSpaceImportMergeErrors.types create mode 100644 tests/baselines/reference/es6ImportNameSpaceImportWithExport.symbols create mode 100644 tests/baselines/reference/es6ImportNameSpaceImportWithExport.types create mode 100644 tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.symbols create mode 100644 tests/baselines/reference/es6ImportNamedImportIdentifiersParsing.types create mode 100644 tests/baselines/reference/es6ImportNamedImportMergeErrors.symbols create mode 100644 tests/baselines/reference/es6ImportNamedImportMergeErrors.types create mode 100644 tests/baselines/reference/es6ImportNamedImportNoExportMember.symbols create mode 100644 tests/baselines/reference/es6ImportNamedImportNoExportMember.types create mode 100644 tests/baselines/reference/es6ImportNamedImportNoNamedExports.symbols create mode 100644 tests/baselines/reference/es6ImportNamedImportNoNamedExports.types create mode 100644 tests/baselines/reference/es6ImportNamedImportParsingError.symbols create mode 100644 tests/baselines/reference/es6ImportNamedImportParsingError.types create mode 100644 tests/baselines/reference/es6ImportNamedImportWithExport.symbols create mode 100644 tests/baselines/reference/es6ImportNamedImportWithExport.types create mode 100644 tests/baselines/reference/es6ImportParseErrors.symbols create mode 100644 tests/baselines/reference/es6ImportParseErrors.types create mode 100644 tests/baselines/reference/es6ImportWithoutFromClauseWithExport.symbols create mode 100644 tests/baselines/reference/es6ImportWithoutFromClauseWithExport.types create mode 100644 tests/baselines/reference/es6MemberScoping.symbols create mode 100644 tests/baselines/reference/es6MemberScoping.types create mode 100644 tests/baselines/reference/es6ModuleInternalNamedImports.symbols create mode 100644 tests/baselines/reference/es6ModuleInternalNamedImports.types create mode 100644 tests/baselines/reference/es6ModuleInternalNamedImports2.symbols create mode 100644 tests/baselines/reference/es6ModuleInternalNamedImports2.types create mode 100644 tests/baselines/reference/es6modulekindWithES5Target10.symbols create mode 100644 tests/baselines/reference/es6modulekindWithES5Target10.types create mode 100644 tests/baselines/reference/es6modulekindWithES5Target9.symbols create mode 100644 tests/baselines/reference/es6modulekindWithES5Target9.types create mode 100644 tests/baselines/reference/esnextmodulekindWithES5Target10.symbols create mode 100644 tests/baselines/reference/esnextmodulekindWithES5Target10.types create mode 100644 tests/baselines/reference/esnextmodulekindWithES5Target9.symbols create mode 100644 tests/baselines/reference/esnextmodulekindWithES5Target9.types create mode 100644 tests/baselines/reference/evalAfter0.symbols create mode 100644 tests/baselines/reference/evalAfter0.types create mode 100644 tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.symbols create mode 100644 tests/baselines/reference/everyTypeWithAnnotationAndInvalidInitializer.types create mode 100644 tests/baselines/reference/exactSpellingSuggestion.symbols create mode 100644 tests/baselines/reference/exactSpellingSuggestion.types create mode 100644 tests/baselines/reference/excessPropertyCheckWithEmptyObject.symbols create mode 100644 tests/baselines/reference/excessPropertyCheckWithEmptyObject.types create mode 100644 tests/baselines/reference/excessPropertyCheckWithSpread.symbols create mode 100644 tests/baselines/reference/excessPropertyCheckWithSpread.types create mode 100644 tests/baselines/reference/excessPropertyErrorForFunctionTypes.symbols create mode 100644 tests/baselines/reference/excessPropertyErrorForFunctionTypes.types create mode 100644 tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError1.types create mode 100644 tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError2.types create mode 100644 tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorInTemplateStringWithSyntaxError3.types create mode 100644 tests/baselines/reference/exponentiationOperatorSyntaxError1.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorSyntaxError1.types create mode 100644 tests/baselines/reference/exponentiationOperatorSyntaxError2.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorSyntaxError2.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithInvalidOperands.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithInvalidOperands.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithInvalidSimpleUnaryExpressionOperands.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithNew.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithNew.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithNullValueAndInvalidOperands.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithOnlyNullValueOrUndefinedValue.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalid.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithTemplateStringInvalidES6.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithTypeParameter.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithTypeParameter.types create mode 100644 tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.symbols create mode 100644 tests/baselines/reference/exponentiationOperatorWithUndefinedValueAndInvalidOperands.types create mode 100644 tests/baselines/reference/exportAlreadySeen.symbols create mode 100644 tests/baselines/reference/exportAlreadySeen.types create mode 100644 tests/baselines/reference/exportAssignNonIdentifier.symbols create mode 100644 tests/baselines/reference/exportAssignNonIdentifier.types create mode 100644 tests/baselines/reference/exportAssignmentAndDeclaration.symbols create mode 100644 tests/baselines/reference/exportAssignmentAndDeclaration.types create mode 100644 tests/baselines/reference/exportAssignmentConstrainedGenericType.symbols create mode 100644 tests/baselines/reference/exportAssignmentConstrainedGenericType.types create mode 100644 tests/baselines/reference/exportAssignmentOfDeclaredExternalModule.symbols create mode 100644 tests/baselines/reference/exportAssignmentOfDeclaredExternalModule.types create mode 100644 tests/baselines/reference/exportAssignmentWithDeclareAndExportModifiers.symbols create mode 100644 tests/baselines/reference/exportAssignmentWithDeclareAndExportModifiers.types create mode 100644 tests/baselines/reference/exportAssignmentWithDeclareModifier.symbols create mode 100644 tests/baselines/reference/exportAssignmentWithDeclareModifier.types create mode 100644 tests/baselines/reference/exportAssignmentWithExportModifier.symbols create mode 100644 tests/baselines/reference/exportAssignmentWithExportModifier.types create mode 100644 tests/baselines/reference/exportAssignmentWithExports.symbols create mode 100644 tests/baselines/reference/exportAssignmentWithExports.types create mode 100644 tests/baselines/reference/exportClassWithoutName.symbols create mode 100644 tests/baselines/reference/exportClassWithoutName.types create mode 100644 tests/baselines/reference/exportDeclarationInInternalModule.symbols create mode 100644 tests/baselines/reference/exportDeclarationInInternalModule.types create mode 100644 tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.symbols create mode 100644 tests/baselines/reference/exportDeclarationsInAmbientNamespaces2.types create mode 100644 tests/baselines/reference/exportDeclareClass1.symbols create mode 100644 tests/baselines/reference/exportDeclareClass1.types create mode 100644 tests/baselines/reference/exportDefaultInJsFile01.symbols create mode 100644 tests/baselines/reference/exportDefaultInJsFile01.types create mode 100644 tests/baselines/reference/exportDefaultInJsFile02.symbols create mode 100644 tests/baselines/reference/exportDefaultInJsFile02.types create mode 100644 tests/baselines/reference/exportEqualErrorType.symbols create mode 100644 tests/baselines/reference/exportEqualErrorType.types create mode 100644 tests/baselines/reference/exportEqualMemberMissing.symbols create mode 100644 tests/baselines/reference/exportEqualMemberMissing.types create mode 100644 tests/baselines/reference/exportEqualsClassRedeclarationError.symbols create mode 100644 tests/baselines/reference/exportEqualsClassRedeclarationError.types create mode 100644 tests/baselines/reference/exportInFunction.symbols create mode 100644 tests/baselines/reference/exportInFunction.types create mode 100644 tests/baselines/reference/exportNonInitializedVariablesAMD.symbols create mode 100644 tests/baselines/reference/exportNonInitializedVariablesAMD.types create mode 100644 tests/baselines/reference/exportNonInitializedVariablesCommonJS.symbols create mode 100644 tests/baselines/reference/exportNonInitializedVariablesCommonJS.types create mode 100644 tests/baselines/reference/exportNonInitializedVariablesES6.symbols create mode 100644 tests/baselines/reference/exportNonInitializedVariablesES6.types create mode 100644 tests/baselines/reference/exportNonInitializedVariablesSystem.symbols create mode 100644 tests/baselines/reference/exportNonInitializedVariablesSystem.types create mode 100644 tests/baselines/reference/exportNonInitializedVariablesUMD.symbols create mode 100644 tests/baselines/reference/exportNonInitializedVariablesUMD.types create mode 100644 tests/baselines/reference/exportSameNameFuncVar.symbols create mode 100644 tests/baselines/reference/exportSameNameFuncVar.types create mode 100644 tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.symbols create mode 100644 tests/baselines/reference/exportSpecifierAndLocalMemberDeclaration.types create mode 100644 tests/baselines/reference/exportSpecifierForAGlobal.symbols create mode 100644 tests/baselines/reference/exportSpecifierForAGlobal.types create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.symbols create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration1.types create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.symbols create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration2.types create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.symbols create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration3.types create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.symbols create mode 100644 tests/baselines/reference/exportSpecifierReferencingOuterDeclaration4.types create mode 100644 tests/baselines/reference/exportStar-amd.symbols create mode 100644 tests/baselines/reference/exportStar-amd.types create mode 100644 tests/baselines/reference/exportStar.symbols create mode 100644 tests/baselines/reference/exportStar.types create mode 100644 tests/baselines/reference/exportStarFromEmptyModule.symbols create mode 100644 tests/baselines/reference/exportStarFromEmptyModule.types create mode 100644 tests/baselines/reference/exportedBlockScopedDeclarations.symbols create mode 100644 tests/baselines/reference/exportedBlockScopedDeclarations.types create mode 100644 tests/baselines/reference/exportingContainingVisibleType.symbols create mode 100644 tests/baselines/reference/exportingContainingVisibleType.types create mode 100644 tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.symbols create mode 100644 tests/baselines/reference/exportsAndImportsWithContextualKeywordNames01.types create mode 100644 tests/baselines/reference/exportsAndImportsWithUnderscores1.symbols create mode 100644 tests/baselines/reference/exportsAndImportsWithUnderscores1.types create mode 100644 tests/baselines/reference/expr.symbols create mode 100644 tests/baselines/reference/expr.types create mode 100644 tests/baselines/reference/expressionTypeNodeShouldError.symbols create mode 100644 tests/baselines/reference/expressionTypeNodeShouldError.types create mode 100644 tests/baselines/reference/extBaseClass2.symbols create mode 100644 tests/baselines/reference/extBaseClass2.types create mode 100644 tests/baselines/reference/extendAndImplementTheSameBaseType2.symbols create mode 100644 tests/baselines/reference/extendAndImplementTheSameBaseType2.types create mode 100644 tests/baselines/reference/extendArray.symbols create mode 100644 tests/baselines/reference/extendArray.types create mode 100644 tests/baselines/reference/extendBaseClassBeforeItsDeclared.symbols create mode 100644 tests/baselines/reference/extendBaseClassBeforeItsDeclared.types create mode 100644 tests/baselines/reference/extendFromAny.symbols create mode 100644 tests/baselines/reference/extendFromAny.types create mode 100644 tests/baselines/reference/extendGenericArray.symbols create mode 100644 tests/baselines/reference/extendGenericArray.types create mode 100644 tests/baselines/reference/extendGenericArray2.symbols create mode 100644 tests/baselines/reference/extendGenericArray2.types create mode 100644 tests/baselines/reference/extendNonClassSymbol2.symbols create mode 100644 tests/baselines/reference/extendNonClassSymbol2.types create mode 100644 tests/baselines/reference/extendPrivateConstructorClass.symbols create mode 100644 tests/baselines/reference/extendPrivateConstructorClass.types create mode 100644 tests/baselines/reference/extendedInterfacesWithDuplicateTypeParameters.symbols create mode 100644 tests/baselines/reference/extendedInterfacesWithDuplicateTypeParameters.types create mode 100644 tests/baselines/reference/extendsClauseAlreadySeen.symbols create mode 100644 tests/baselines/reference/extendsClauseAlreadySeen.types create mode 100644 tests/baselines/reference/extendsClauseAlreadySeen2.symbols create mode 100644 tests/baselines/reference/extendsClauseAlreadySeen2.types create mode 100644 tests/baselines/reference/extendsUntypedModule.symbols create mode 100644 tests/baselines/reference/extendsUntypedModule.types create mode 100644 tests/baselines/reference/extension.symbols create mode 100644 tests/baselines/reference/extension.types create mode 100644 tests/baselines/reference/externModule.symbols create mode 100644 tests/baselines/reference/externModule.types create mode 100644 tests/baselines/reference/externSemantics.symbols create mode 100644 tests/baselines/reference/externSemantics.types create mode 100644 tests/baselines/reference/externSyntax.symbols create mode 100644 tests/baselines/reference/externSyntax.types create mode 100644 tests/baselines/reference/externalModuleExportingGenericClass.symbols create mode 100644 tests/baselines/reference/externalModuleExportingGenericClass.types create mode 100644 tests/baselines/reference/externalModuleImmutableBindings.symbols create mode 100644 tests/baselines/reference/externalModuleImmutableBindings.types create mode 100644 tests/baselines/reference/externalModuleRefernceResolutionOrderInImportDeclaration.symbols create mode 100644 tests/baselines/reference/externalModuleRefernceResolutionOrderInImportDeclaration.types create mode 100644 tests/baselines/reference/fallFromLastCase2.symbols create mode 100644 tests/baselines/reference/fallFromLastCase2.types create mode 100644 tests/baselines/reference/fatarrowfunctionsErrors.symbols create mode 100644 tests/baselines/reference/fatarrowfunctionsErrors.types create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgs.symbols create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgs.types create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors1.symbols create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors1.types create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors2.symbols create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors2.types create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors3.symbols create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors3.types create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors4.symbols create mode 100644 tests/baselines/reference/fatarrowfunctionsOptionalArgsErrors4.types create mode 100644 tests/baselines/reference/fieldAndGetterWithSameName.symbols create mode 100644 tests/baselines/reference/fieldAndGetterWithSameName.types create mode 100644 tests/baselines/reference/fileWithNextLine3.symbols create mode 100644 tests/baselines/reference/fileWithNextLine3.types create mode 100644 tests/baselines/reference/filesEmittingIntoSameOutput.symbols create mode 100644 tests/baselines/reference/filesEmittingIntoSameOutput.types create mode 100644 tests/baselines/reference/fillInMissingTypeArgsOnJSConstructCalls.symbols create mode 100644 tests/baselines/reference/fillInMissingTypeArgsOnJSConstructCalls.types create mode 100644 tests/baselines/reference/fixSignatureCaching.symbols create mode 100644 tests/baselines/reference/fixSignatureCaching.types create mode 100644 tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.symbols create mode 100644 tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.types create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly2.symbols create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly2.types create mode 100644 tests/baselines/reference/for-inStatements.symbols create mode 100644 tests/baselines/reference/for-inStatements.types create mode 100644 tests/baselines/reference/for-inStatementsArrayErrors.symbols create mode 100644 tests/baselines/reference/for-inStatementsArrayErrors.types create mode 100644 tests/baselines/reference/for-inStatementsDestructuring.symbols create mode 100644 tests/baselines/reference/for-inStatementsDestructuring.types create mode 100644 tests/baselines/reference/for-inStatementsDestructuring2.symbols create mode 100644 tests/baselines/reference/for-inStatementsDestructuring2.types create mode 100644 tests/baselines/reference/for-inStatementsDestructuring3.symbols create mode 100644 tests/baselines/reference/for-inStatementsDestructuring3.types create mode 100644 tests/baselines/reference/for-inStatementsDestructuring4.symbols create mode 100644 tests/baselines/reference/for-inStatementsDestructuring4.types create mode 100644 tests/baselines/reference/for-inStatementsInvalid.symbols create mode 100644 tests/baselines/reference/for-inStatementsInvalid.types create mode 100644 tests/baselines/reference/for-of10.symbols create mode 100644 tests/baselines/reference/for-of10.types create mode 100644 tests/baselines/reference/for-of11.symbols create mode 100644 tests/baselines/reference/for-of11.types create mode 100644 tests/baselines/reference/for-of12.symbols create mode 100644 tests/baselines/reference/for-of12.types create mode 100644 tests/baselines/reference/for-of14.symbols create mode 100644 tests/baselines/reference/for-of14.types create mode 100644 tests/baselines/reference/for-of15.symbols create mode 100644 tests/baselines/reference/for-of15.types create mode 100644 tests/baselines/reference/for-of16.symbols create mode 100644 tests/baselines/reference/for-of16.types create mode 100644 tests/baselines/reference/for-of17.symbols create mode 100644 tests/baselines/reference/for-of17.types create mode 100644 tests/baselines/reference/for-of2.symbols create mode 100644 tests/baselines/reference/for-of2.types create mode 100644 tests/baselines/reference/for-of29.symbols create mode 100644 tests/baselines/reference/for-of29.types create mode 100644 tests/baselines/reference/for-of3.symbols create mode 100644 tests/baselines/reference/for-of3.types create mode 100644 tests/baselines/reference/for-of30.symbols create mode 100644 tests/baselines/reference/for-of30.types create mode 100644 tests/baselines/reference/for-of31.symbols create mode 100644 tests/baselines/reference/for-of31.types create mode 100644 tests/baselines/reference/for-of32.symbols create mode 100644 tests/baselines/reference/for-of32.types create mode 100644 tests/baselines/reference/for-of33.symbols create mode 100644 tests/baselines/reference/for-of33.types create mode 100644 tests/baselines/reference/for-of34.symbols create mode 100644 tests/baselines/reference/for-of34.types create mode 100644 tests/baselines/reference/for-of35.symbols create mode 100644 tests/baselines/reference/for-of35.types create mode 100644 tests/baselines/reference/for-of39.symbols create mode 100644 tests/baselines/reference/for-of39.types create mode 100644 tests/baselines/reference/for-of46.symbols create mode 100644 tests/baselines/reference/for-of46.types create mode 100644 tests/baselines/reference/for-of47.symbols create mode 100644 tests/baselines/reference/for-of47.types create mode 100644 tests/baselines/reference/for-of48.symbols create mode 100644 tests/baselines/reference/for-of48.types create mode 100644 tests/baselines/reference/for-of49.symbols create mode 100644 tests/baselines/reference/for-of49.types create mode 100644 tests/baselines/reference/for-of51.symbols create mode 100644 tests/baselines/reference/for-of51.types create mode 100644 tests/baselines/reference/for-of52.symbols create mode 100644 tests/baselines/reference/for-of52.types create mode 100644 tests/baselines/reference/for-of54.symbols create mode 100644 tests/baselines/reference/for-of54.types create mode 100644 tests/baselines/reference/for-of55.symbols create mode 100644 tests/baselines/reference/for-of55.types create mode 100644 tests/baselines/reference/for-of6.symbols create mode 100644 tests/baselines/reference/for-of6.types create mode 100644 tests/baselines/reference/for-of7.symbols create mode 100644 tests/baselines/reference/for-of7.types create mode 100644 tests/baselines/reference/for.symbols create mode 100644 tests/baselines/reference/for.types create mode 100644 tests/baselines/reference/forIn.symbols create mode 100644 tests/baselines/reference/forIn.types create mode 100644 tests/baselines/reference/forIn2.symbols create mode 100644 tests/baselines/reference/forIn2.types create mode 100644 tests/baselines/reference/forInStatement2.symbols create mode 100644 tests/baselines/reference/forInStatement2.types create mode 100644 tests/baselines/reference/forInStatement4.symbols create mode 100644 tests/baselines/reference/forInStatement4.types create mode 100644 tests/baselines/reference/forInStatement7.symbols create mode 100644 tests/baselines/reference/forInStatement7.types create mode 100644 tests/baselines/reference/forStatementsMultipleInvalidDecl.symbols create mode 100644 tests/baselines/reference/forStatementsMultipleInvalidDecl.types create mode 100644 tests/baselines/reference/forgottenNew.symbols create mode 100644 tests/baselines/reference/forgottenNew.types create mode 100644 tests/baselines/reference/forwardRefInClassProperties.symbols create mode 100644 tests/baselines/reference/forwardRefInClassProperties.types create mode 100644 tests/baselines/reference/forwardRefInEnum.symbols create mode 100644 tests/baselines/reference/forwardRefInEnum.types create mode 100644 tests/baselines/reference/funClodule.symbols create mode 100644 tests/baselines/reference/funClodule.types create mode 100644 tests/baselines/reference/functionAndImportNameConflict.symbols create mode 100644 tests/baselines/reference/functionAndImportNameConflict.types create mode 100644 tests/baselines/reference/functionAndInterfaceWithSeparateErrors.symbols create mode 100644 tests/baselines/reference/functionAndInterfaceWithSeparateErrors.types create mode 100644 tests/baselines/reference/functionAndPropertyNameConflict.symbols create mode 100644 tests/baselines/reference/functionAndPropertyNameConflict.types create mode 100644 tests/baselines/reference/functionArgShadowing.symbols create mode 100644 tests/baselines/reference/functionArgShadowing.types create mode 100644 tests/baselines/reference/functionAssignment.symbols create mode 100644 tests/baselines/reference/functionAssignment.types create mode 100644 tests/baselines/reference/functionCall10.symbols create mode 100644 tests/baselines/reference/functionCall10.types create mode 100644 tests/baselines/reference/functionCall11.symbols create mode 100644 tests/baselines/reference/functionCall11.types create mode 100644 tests/baselines/reference/functionCall12.symbols create mode 100644 tests/baselines/reference/functionCall12.types create mode 100644 tests/baselines/reference/functionCall13.symbols create mode 100644 tests/baselines/reference/functionCall13.types create mode 100644 tests/baselines/reference/functionCall14.symbols create mode 100644 tests/baselines/reference/functionCall14.types create mode 100644 tests/baselines/reference/functionCall15.symbols create mode 100644 tests/baselines/reference/functionCall15.types create mode 100644 tests/baselines/reference/functionCall16.symbols create mode 100644 tests/baselines/reference/functionCall16.types create mode 100644 tests/baselines/reference/functionCall17.symbols create mode 100644 tests/baselines/reference/functionCall17.types create mode 100644 tests/baselines/reference/functionCall6.symbols create mode 100644 tests/baselines/reference/functionCall6.types create mode 100644 tests/baselines/reference/functionCall7.symbols create mode 100644 tests/baselines/reference/functionCall7.types create mode 100644 tests/baselines/reference/functionCall8.symbols create mode 100644 tests/baselines/reference/functionCall8.types create mode 100644 tests/baselines/reference/functionCall9.symbols create mode 100644 tests/baselines/reference/functionCall9.types create mode 100644 tests/baselines/reference/functionCalls.symbols create mode 100644 tests/baselines/reference/functionCalls.types create mode 100644 tests/baselines/reference/functionConstraintSatisfaction2.symbols create mode 100644 tests/baselines/reference/functionConstraintSatisfaction2.types create mode 100644 tests/baselines/reference/functionExpressionContextualTyping2.symbols create mode 100644 tests/baselines/reference/functionExpressionContextualTyping2.types create mode 100644 tests/baselines/reference/functionExpressionInWithBlock.symbols create mode 100644 tests/baselines/reference/functionExpressionInWithBlock.types create mode 100644 tests/baselines/reference/functionExpressionShadowedByParams.symbols create mode 100644 tests/baselines/reference/functionExpressionShadowedByParams.types create mode 100644 tests/baselines/reference/functionImplementationErrors.symbols create mode 100644 tests/baselines/reference/functionImplementationErrors.types create mode 100644 tests/baselines/reference/functionLikeInParameterInitializer.symbols create mode 100644 tests/baselines/reference/functionLikeInParameterInitializer.types create mode 100644 tests/baselines/reference/functionNameConflicts.symbols create mode 100644 tests/baselines/reference/functionNameConflicts.types create mode 100644 tests/baselines/reference/functionOverloadAmbiguity1.symbols create mode 100644 tests/baselines/reference/functionOverloadAmbiguity1.types create mode 100644 tests/baselines/reference/functionOverloadCompatibilityWithVoid01.symbols create mode 100644 tests/baselines/reference/functionOverloadCompatibilityWithVoid01.types create mode 100644 tests/baselines/reference/functionOverloadErrors.symbols create mode 100644 tests/baselines/reference/functionOverloadErrors.types create mode 100644 tests/baselines/reference/functionOverloadErrorsSyntax.symbols create mode 100644 tests/baselines/reference/functionOverloadErrorsSyntax.types create mode 100644 tests/baselines/reference/functionOverloadImplementationOfWrongName.symbols create mode 100644 tests/baselines/reference/functionOverloadImplementationOfWrongName.types create mode 100644 tests/baselines/reference/functionOverloadImplementationOfWrongName2.symbols create mode 100644 tests/baselines/reference/functionOverloadImplementationOfWrongName2.types create mode 100644 tests/baselines/reference/functionOverloads.symbols create mode 100644 tests/baselines/reference/functionOverloads.types create mode 100644 tests/baselines/reference/functionOverloads1.symbols create mode 100644 tests/baselines/reference/functionOverloads1.types create mode 100644 tests/baselines/reference/functionOverloads11.symbols create mode 100644 tests/baselines/reference/functionOverloads11.types create mode 100644 tests/baselines/reference/functionOverloads17.symbols create mode 100644 tests/baselines/reference/functionOverloads17.types create mode 100644 tests/baselines/reference/functionOverloads18.symbols create mode 100644 tests/baselines/reference/functionOverloads18.types create mode 100644 tests/baselines/reference/functionOverloads19.symbols create mode 100644 tests/baselines/reference/functionOverloads19.types create mode 100644 tests/baselines/reference/functionOverloads2.symbols create mode 100644 tests/baselines/reference/functionOverloads2.types create mode 100644 tests/baselines/reference/functionOverloads20.symbols create mode 100644 tests/baselines/reference/functionOverloads20.types create mode 100644 tests/baselines/reference/functionOverloads27.symbols create mode 100644 tests/baselines/reference/functionOverloads27.types create mode 100644 tests/baselines/reference/functionOverloads29.symbols create mode 100644 tests/baselines/reference/functionOverloads29.types create mode 100644 tests/baselines/reference/functionOverloads3.symbols create mode 100644 tests/baselines/reference/functionOverloads3.types create mode 100644 tests/baselines/reference/functionOverloads34.symbols create mode 100644 tests/baselines/reference/functionOverloads34.types create mode 100644 tests/baselines/reference/functionOverloads37.symbols create mode 100644 tests/baselines/reference/functionOverloads37.types create mode 100644 tests/baselines/reference/functionOverloads4.symbols create mode 100644 tests/baselines/reference/functionOverloads4.types create mode 100644 tests/baselines/reference/functionOverloads40.symbols create mode 100644 tests/baselines/reference/functionOverloads40.types create mode 100644 tests/baselines/reference/functionOverloads41.symbols create mode 100644 tests/baselines/reference/functionOverloads41.types create mode 100644 tests/baselines/reference/functionOverloads5.symbols create mode 100644 tests/baselines/reference/functionOverloads5.types create mode 100644 tests/baselines/reference/functionOverloadsOutOfOrder.symbols create mode 100644 tests/baselines/reference/functionOverloadsOutOfOrder.types create mode 100644 tests/baselines/reference/functionSignatureAssignmentCompat1.symbols create mode 100644 tests/baselines/reference/functionSignatureAssignmentCompat1.types create mode 100644 tests/baselines/reference/functionTypeArgumentAssignmentCompat.symbols create mode 100644 tests/baselines/reference/functionTypeArgumentAssignmentCompat.types create mode 100644 tests/baselines/reference/functionTypesLackingReturnTypes.symbols create mode 100644 tests/baselines/reference/functionTypesLackingReturnTypes.types create mode 100644 tests/baselines/reference/functionVariableInReturnTypeAnnotation.symbols create mode 100644 tests/baselines/reference/functionVariableInReturnTypeAnnotation.types create mode 100644 tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.symbols create mode 100644 tests/baselines/reference/functionWithDefaultParameterWithNoStatements9.types create mode 100644 tests/baselines/reference/functionWithSameNameAsField.symbols create mode 100644 tests/baselines/reference/functionWithSameNameAsField.types create mode 100644 tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.symbols create mode 100644 tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.types create mode 100644 tests/baselines/reference/functionsWithModifiersInBlocks1.symbols create mode 100644 tests/baselines/reference/functionsWithModifiersInBlocks1.types create mode 100644 tests/baselines/reference/funduleSplitAcrossFiles.symbols create mode 100644 tests/baselines/reference/funduleSplitAcrossFiles.types create mode 100644 tests/baselines/reference/fuzzy.symbols create mode 100644 tests/baselines/reference/fuzzy.types create mode 100644 tests/baselines/reference/generatorES6_5.symbols create mode 100644 tests/baselines/reference/generatorES6_5.types create mode 100644 tests/baselines/reference/generatorInAmbientContext1.symbols create mode 100644 tests/baselines/reference/generatorInAmbientContext1.types create mode 100644 tests/baselines/reference/generatorInAmbientContext2.symbols create mode 100644 tests/baselines/reference/generatorInAmbientContext2.types create mode 100644 tests/baselines/reference/generatorInAmbientContext3.d.symbols create mode 100644 tests/baselines/reference/generatorInAmbientContext3.d.types create mode 100644 tests/baselines/reference/generatorInAmbientContext4.d.symbols create mode 100644 tests/baselines/reference/generatorInAmbientContext4.d.types create mode 100644 tests/baselines/reference/generatorOverloads1.symbols create mode 100644 tests/baselines/reference/generatorOverloads1.types create mode 100644 tests/baselines/reference/generatorOverloads2.symbols create mode 100644 tests/baselines/reference/generatorOverloads2.types create mode 100644 tests/baselines/reference/generatorOverloads3.symbols create mode 100644 tests/baselines/reference/generatorOverloads3.types create mode 100644 tests/baselines/reference/generatorTypeCheck18.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck18.types create mode 100644 tests/baselines/reference/generatorTypeCheck20.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck20.types create mode 100644 tests/baselines/reference/generatorTypeCheck21.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck21.types create mode 100644 tests/baselines/reference/generatorTypeCheck25.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck25.types create mode 100644 tests/baselines/reference/generatorTypeCheck31.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck31.types create mode 100644 tests/baselines/reference/generatorTypeCheck32.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck32.types create mode 100644 tests/baselines/reference/generatorTypeCheck39.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck39.types create mode 100644 tests/baselines/reference/generatorTypeCheck40.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck40.types create mode 100644 tests/baselines/reference/generatorTypeCheck47.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck47.types create mode 100644 tests/baselines/reference/generatorTypeCheck48.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck48.types create mode 100644 tests/baselines/reference/generatorTypeCheck51.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck51.types create mode 100644 tests/baselines/reference/generatorTypeCheck55.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck55.types create mode 100644 tests/baselines/reference/generatorTypeCheck56.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck56.types create mode 100644 tests/baselines/reference/generatorTypeCheck57.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck57.types create mode 100644 tests/baselines/reference/generatorTypeCheck58.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck58.types create mode 100644 tests/baselines/reference/generatorTypeCheck59.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck59.types create mode 100644 tests/baselines/reference/generatorTypeCheck6.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck6.types create mode 100644 tests/baselines/reference/generatorTypeCheck60.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck60.types create mode 100644 tests/baselines/reference/generatorTypeCheck61.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck61.types create mode 100644 tests/baselines/reference/generatorTypeCheck63.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck63.types create mode 100644 tests/baselines/reference/generatorTypeCheck7.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck7.types create mode 100644 tests/baselines/reference/generatorTypeCheck8.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck8.types create mode 100644 tests/baselines/reference/generatorTypeCheck9.symbols create mode 100644 tests/baselines/reference/generatorTypeCheck9.types create mode 100644 tests/baselines/reference/genericAndNonGenericInheritedSignature1.symbols create mode 100644 tests/baselines/reference/genericAndNonGenericInheritedSignature1.types create mode 100644 tests/baselines/reference/genericAndNonGenericInheritedSignature2.symbols create mode 100644 tests/baselines/reference/genericAndNonGenericInheritedSignature2.types create mode 100644 tests/baselines/reference/genericAndNonGenericInterfaceWithTheSameName.symbols create mode 100644 tests/baselines/reference/genericAndNonGenericInterfaceWithTheSameName.types create mode 100644 tests/baselines/reference/genericArrayAssignment1.symbols create mode 100644 tests/baselines/reference/genericArrayAssignment1.types create mode 100644 tests/baselines/reference/genericArrayAssignmentCompatErrors.symbols create mode 100644 tests/baselines/reference/genericArrayAssignmentCompatErrors.types create mode 100644 tests/baselines/reference/genericArrayExtenstions.symbols create mode 100644 tests/baselines/reference/genericArrayExtenstions.types create mode 100644 tests/baselines/reference/genericArrayMethods1.symbols create mode 100644 tests/baselines/reference/genericArrayMethods1.types create mode 100644 tests/baselines/reference/genericArrayWithoutTypeAnnotation.symbols create mode 100644 tests/baselines/reference/genericArrayWithoutTypeAnnotation.types create mode 100644 tests/baselines/reference/genericAssignmentCompatWithInterfaces1.symbols create mode 100644 tests/baselines/reference/genericAssignmentCompatWithInterfaces1.types create mode 100644 tests/baselines/reference/genericCallSpecializedToTypeArg.symbols create mode 100644 tests/baselines/reference/genericCallSpecializedToTypeArg.types create mode 100644 tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.symbols create mode 100644 tests/baselines/reference/genericCallToOverloadedMethodWithOverloadedArguments.types create mode 100644 tests/baselines/reference/genericCallWithConstraintsTypeArgumentInference2.symbols create mode 100644 tests/baselines/reference/genericCallWithConstraintsTypeArgumentInference2.types create mode 100644 tests/baselines/reference/genericCallWithConstructorTypedArguments5.symbols create mode 100644 tests/baselines/reference/genericCallWithConstructorTypedArguments5.types create mode 100644 tests/baselines/reference/genericCallWithFunctionTypedArguments.symbols create mode 100644 tests/baselines/reference/genericCallWithFunctionTypedArguments.types create mode 100644 tests/baselines/reference/genericCallWithFunctionTypedArguments2.symbols create mode 100644 tests/baselines/reference/genericCallWithFunctionTypedArguments2.types create mode 100644 tests/baselines/reference/genericCallWithFunctionTypedArguments5.symbols create mode 100644 tests/baselines/reference/genericCallWithFunctionTypedArguments5.types create mode 100644 tests/baselines/reference/genericCallWithGenericSignatureArguments2.symbols create mode 100644 tests/baselines/reference/genericCallWithGenericSignatureArguments2.types create mode 100644 tests/baselines/reference/genericCallWithGenericSignatureArguments3.symbols create mode 100644 tests/baselines/reference/genericCallWithGenericSignatureArguments3.types create mode 100644 tests/baselines/reference/genericCallWithObjectLiteralArgs.symbols create mode 100644 tests/baselines/reference/genericCallWithObjectLiteralArgs.types create mode 100644 tests/baselines/reference/genericCallWithObjectLiteralArguments1.symbols create mode 100644 tests/baselines/reference/genericCallWithObjectLiteralArguments1.types create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgs.symbols create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgs.types create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints3.symbols create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints3.types create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints4.symbols create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints4.types create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints5.symbols create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints5.types create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndInitializers.symbols create mode 100644 tests/baselines/reference/genericCallWithObjectTypeArgsAndInitializers.types create mode 100644 tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments2.symbols create mode 100644 tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments2.types create mode 100644 tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments2.symbols create mode 100644 tests/baselines/reference/genericCallWithOverloadedFunctionTypedArguments2.types create mode 100644 tests/baselines/reference/genericCallWithTupleType.symbols create mode 100644 tests/baselines/reference/genericCallWithTupleType.types create mode 100644 tests/baselines/reference/genericCallWithoutArgs.symbols create mode 100644 tests/baselines/reference/genericCallWithoutArgs.types create mode 100644 tests/baselines/reference/genericCallbackInvokedInsideItsContainingFunction1.symbols create mode 100644 tests/baselines/reference/genericCallbackInvokedInsideItsContainingFunction1.types create mode 100644 tests/baselines/reference/genericCallsWithoutParens.symbols create mode 100644 tests/baselines/reference/genericCallsWithoutParens.types create mode 100644 tests/baselines/reference/genericChainedCalls.symbols create mode 100644 tests/baselines/reference/genericChainedCalls.types create mode 100644 tests/baselines/reference/genericClassInheritsConstructorFromNonGenericClass.symbols create mode 100644 tests/baselines/reference/genericClassInheritsConstructorFromNonGenericClass.types create mode 100644 tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.symbols create mode 100644 tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.types create mode 100644 tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.symbols create mode 100644 tests/baselines/reference/genericClassWithStaticsUsingTypeArguments.types create mode 100644 tests/baselines/reference/genericClassesRedeclaration.symbols create mode 100644 tests/baselines/reference/genericClassesRedeclaration.types create mode 100644 tests/baselines/reference/genericCloduleInModule2.symbols create mode 100644 tests/baselines/reference/genericCloduleInModule2.types create mode 100644 tests/baselines/reference/genericCloneReturnTypes.symbols create mode 100644 tests/baselines/reference/genericCloneReturnTypes.types create mode 100644 tests/baselines/reference/genericCloneReturnTypes2.symbols create mode 100644 tests/baselines/reference/genericCloneReturnTypes2.types create mode 100644 tests/baselines/reference/genericCombinators2.symbols create mode 100644 tests/baselines/reference/genericCombinators2.types create mode 100644 tests/baselines/reference/genericConstraint1.symbols create mode 100644 tests/baselines/reference/genericConstraint1.types create mode 100644 tests/baselines/reference/genericConstraint2.symbols create mode 100644 tests/baselines/reference/genericConstraint2.types create mode 100644 tests/baselines/reference/genericConstraintSatisfaction1.symbols create mode 100644 tests/baselines/reference/genericConstraintSatisfaction1.types create mode 100644 tests/baselines/reference/genericConstructExpressionWithoutArgs.symbols create mode 100644 tests/baselines/reference/genericConstructExpressionWithoutArgs.types create mode 100644 tests/baselines/reference/genericConstructInvocationWithNoTypeArg.symbols create mode 100644 tests/baselines/reference/genericConstructInvocationWithNoTypeArg.types create mode 100644 tests/baselines/reference/genericConstructorFunction1.symbols create mode 100644 tests/baselines/reference/genericConstructorFunction1.types create mode 100644 tests/baselines/reference/genericDefaultsErrors.symbols create mode 100644 tests/baselines/reference/genericDefaultsErrors.types create mode 100644 tests/baselines/reference/genericDerivedTypeWithSpecializedBase.symbols create mode 100644 tests/baselines/reference/genericDerivedTypeWithSpecializedBase.types create mode 100644 tests/baselines/reference/genericDerivedTypeWithSpecializedBase2.symbols create mode 100644 tests/baselines/reference/genericDerivedTypeWithSpecializedBase2.types create mode 100644 tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.symbols create mode 100644 tests/baselines/reference/genericFunctionCallSignatureReturnTypeMismatch.types create mode 100644 tests/baselines/reference/genericFunctionTypedArgumentsAreFixed.symbols create mode 100644 tests/baselines/reference/genericFunctionTypedArgumentsAreFixed.types create mode 100644 tests/baselines/reference/genericFunctionsWithOptionalParameters2.symbols create mode 100644 tests/baselines/reference/genericFunctionsWithOptionalParameters2.types create mode 100644 tests/baselines/reference/genericFunduleInModule.symbols create mode 100644 tests/baselines/reference/genericFunduleInModule.types create mode 100644 tests/baselines/reference/genericFunduleInModule2.symbols create mode 100644 tests/baselines/reference/genericFunduleInModule2.types create mode 100644 tests/baselines/reference/genericGetter.symbols create mode 100644 tests/baselines/reference/genericGetter.types create mode 100644 tests/baselines/reference/genericGetter2.symbols create mode 100644 tests/baselines/reference/genericGetter2.types create mode 100644 tests/baselines/reference/genericGetter3.symbols create mode 100644 tests/baselines/reference/genericGetter3.types create mode 100644 tests/baselines/reference/genericInterfacesWithoutTypeArguments.symbols create mode 100644 tests/baselines/reference/genericInterfacesWithoutTypeArguments.types create mode 100644 tests/baselines/reference/genericLambaArgWithoutTypeArguments.symbols create mode 100644 tests/baselines/reference/genericLambaArgWithoutTypeArguments.types create mode 100644 tests/baselines/reference/genericMemberFunction.symbols create mode 100644 tests/baselines/reference/genericMemberFunction.types create mode 100644 tests/baselines/reference/genericMergedDeclarationUsingTypeParameter.symbols create mode 100644 tests/baselines/reference/genericMergedDeclarationUsingTypeParameter.types create mode 100644 tests/baselines/reference/genericMergedDeclarationUsingTypeParameter2.symbols create mode 100644 tests/baselines/reference/genericMergedDeclarationUsingTypeParameter2.types create mode 100644 tests/baselines/reference/genericNewInterface.symbols create mode 100644 tests/baselines/reference/genericNewInterface.types create mode 100644 tests/baselines/reference/genericObjectCreationWithoutTypeArgs.symbols create mode 100644 tests/baselines/reference/genericObjectCreationWithoutTypeArgs.types create mode 100644 tests/baselines/reference/genericRecursiveImplicitConstructorErrors1.symbols create mode 100644 tests/baselines/reference/genericRecursiveImplicitConstructorErrors1.types create mode 100644 tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.symbols create mode 100644 tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.types create mode 100644 tests/baselines/reference/genericReduce.symbols create mode 100644 tests/baselines/reference/genericReduce.types create mode 100644 tests/baselines/reference/genericRestArgs.symbols create mode 100644 tests/baselines/reference/genericRestArgs.types create mode 100644 tests/baselines/reference/genericReturnTypeFromGetter1.symbols create mode 100644 tests/baselines/reference/genericReturnTypeFromGetter1.types create mode 100644 tests/baselines/reference/genericSpecializations2.symbols create mode 100644 tests/baselines/reference/genericSpecializations2.types create mode 100644 tests/baselines/reference/genericSpecializations3.symbols create mode 100644 tests/baselines/reference/genericSpecializations3.types create mode 100644 tests/baselines/reference/genericTypeAssertions1.symbols create mode 100644 tests/baselines/reference/genericTypeAssertions1.types create mode 100644 tests/baselines/reference/genericTypeAssertions2.symbols create mode 100644 tests/baselines/reference/genericTypeAssertions2.types create mode 100644 tests/baselines/reference/genericTypeAssertions4.symbols create mode 100644 tests/baselines/reference/genericTypeAssertions4.types create mode 100644 tests/baselines/reference/genericTypeAssertions5.symbols create mode 100644 tests/baselines/reference/genericTypeAssertions5.types create mode 100644 tests/baselines/reference/genericTypeAssertions6.symbols create mode 100644 tests/baselines/reference/genericTypeAssertions6.types create mode 100644 tests/baselines/reference/genericTypeConstraints.symbols create mode 100644 tests/baselines/reference/genericTypeConstraints.types create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.d.symbols create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.d.types create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.symbols create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.types create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.symbols create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.types create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument3.symbols create mode 100644 tests/baselines/reference/genericTypeReferenceWithoutTypeArgument3.types create mode 100644 tests/baselines/reference/genericTypeReferencesRequireTypeArgs.symbols create mode 100644 tests/baselines/reference/genericTypeReferencesRequireTypeArgs.types create mode 100644 tests/baselines/reference/genericTypeUsedWithoutTypeArguments1.symbols create mode 100644 tests/baselines/reference/genericTypeUsedWithoutTypeArguments1.types create mode 100644 tests/baselines/reference/genericTypeUsedWithoutTypeArguments3.symbols create mode 100644 tests/baselines/reference/genericTypeUsedWithoutTypeArguments3.types create mode 100644 tests/baselines/reference/genericTypeWithNonGenericBaseMisMatch.symbols create mode 100644 tests/baselines/reference/genericTypeWithNonGenericBaseMisMatch.types create mode 100644 tests/baselines/reference/genericWithOpenTypeParameters1.symbols create mode 100644 tests/baselines/reference/genericWithOpenTypeParameters1.types create mode 100644 tests/baselines/reference/generics1.symbols create mode 100644 tests/baselines/reference/generics1.types create mode 100644 tests/baselines/reference/generics2.symbols create mode 100644 tests/baselines/reference/generics2.types create mode 100644 tests/baselines/reference/generics4.symbols create mode 100644 tests/baselines/reference/generics4.types create mode 100644 tests/baselines/reference/generics5.symbols create mode 100644 tests/baselines/reference/generics5.types create mode 100644 tests/baselines/reference/genericsWithDuplicateTypeParameters1.symbols create mode 100644 tests/baselines/reference/genericsWithDuplicateTypeParameters1.types create mode 100644 tests/baselines/reference/genericsWithoutTypeParameters1.symbols create mode 100644 tests/baselines/reference/genericsWithoutTypeParameters1.types create mode 100644 tests/baselines/reference/getAccessorWithImpliedReturnTypeAndFunctionClassMerge.symbols create mode 100644 tests/baselines/reference/getAccessorWithImpliedReturnTypeAndFunctionClassMerge.types create mode 100644 tests/baselines/reference/getAndSetAsMemberNames.symbols create mode 100644 tests/baselines/reference/getAndSetAsMemberNames.types create mode 100644 tests/baselines/reference/getAndSetNotIdenticalType.symbols create mode 100644 tests/baselines/reference/getAndSetNotIdenticalType.types create mode 100644 tests/baselines/reference/getAndSetNotIdenticalType2.symbols create mode 100644 tests/baselines/reference/getAndSetNotIdenticalType2.types create mode 100644 tests/baselines/reference/getAndSetNotIdenticalType3.symbols create mode 100644 tests/baselines/reference/getAndSetNotIdenticalType3.types create mode 100644 tests/baselines/reference/getSetAccessorContextualTyping.symbols create mode 100644 tests/baselines/reference/getSetAccessorContextualTyping.types create mode 100644 tests/baselines/reference/getsetReturnTypes.symbols create mode 100644 tests/baselines/reference/getsetReturnTypes.types create mode 100644 tests/baselines/reference/getterControlFlowStrictNull.symbols create mode 100644 tests/baselines/reference/getterControlFlowStrictNull.types create mode 100644 tests/baselines/reference/getterMissingReturnError.symbols create mode 100644 tests/baselines/reference/getterMissingReturnError.types create mode 100644 tests/baselines/reference/getterThatThrowsShouldNotNeedReturn.symbols create mode 100644 tests/baselines/reference/getterThatThrowsShouldNotNeedReturn.types create mode 100644 tests/baselines/reference/gettersAndSetters.symbols create mode 100644 tests/baselines/reference/gettersAndSetters.types create mode 100644 tests/baselines/reference/gettersAndSettersAccessibility.symbols create mode 100644 tests/baselines/reference/gettersAndSettersAccessibility.types create mode 100644 tests/baselines/reference/gettersAndSettersErrors.symbols create mode 100644 tests/baselines/reference/gettersAndSettersErrors.types create mode 100644 tests/baselines/reference/gettersAndSettersTypesAgree.symbols create mode 100644 tests/baselines/reference/gettersAndSettersTypesAgree.types create mode 100644 tests/baselines/reference/giant.symbols create mode 100644 tests/baselines/reference/giant.types create mode 100644 tests/baselines/reference/grammarAmbiguities.symbols create mode 100644 tests/baselines/reference/grammarAmbiguities.types create mode 100644 tests/baselines/reference/grammarAmbiguities1.symbols create mode 100644 tests/baselines/reference/grammarAmbiguities1.types create mode 100644 tests/baselines/reference/heterogeneousArrayAndOverloads.symbols create mode 100644 tests/baselines/reference/heterogeneousArrayAndOverloads.types create mode 100644 tests/baselines/reference/i3.symbols create mode 100644 tests/baselines/reference/i3.types create mode 100644 tests/baselines/reference/identityForSignaturesWithTypeParametersAndAny.symbols create mode 100644 tests/baselines/reference/identityForSignaturesWithTypeParametersAndAny.types create mode 100644 tests/baselines/reference/ifElseWithStatements1.symbols create mode 100644 tests/baselines/reference/ifElseWithStatements1.types create mode 100644 tests/baselines/reference/illegalModifiersOnClassElements.symbols create mode 100644 tests/baselines/reference/illegalModifiersOnClassElements.types create mode 100644 tests/baselines/reference/illegalSuperCallsInConstructor.symbols create mode 100644 tests/baselines/reference/illegalSuperCallsInConstructor.types create mode 100644 tests/baselines/reference/implementClausePrecedingExtends.symbols create mode 100644 tests/baselines/reference/implementClausePrecedingExtends.types create mode 100644 tests/baselines/reference/implementGenericWithMismatchedTypes.symbols create mode 100644 tests/baselines/reference/implementGenericWithMismatchedTypes.types create mode 100644 tests/baselines/reference/implementPublicPropertyAsPrivate.symbols create mode 100644 tests/baselines/reference/implementPublicPropertyAsPrivate.types create mode 100644 tests/baselines/reference/implementingAnInterfaceExtendingClassWithPrivates.symbols create mode 100644 tests/baselines/reference/implementingAnInterfaceExtendingClassWithPrivates.types create mode 100644 tests/baselines/reference/implementingAnInterfaceExtendingClassWithPrivates2.symbols create mode 100644 tests/baselines/reference/implementingAnInterfaceExtendingClassWithPrivates2.types create mode 100644 tests/baselines/reference/implementingAnInterfaceExtendingClassWithProtecteds.symbols create mode 100644 tests/baselines/reference/implementingAnInterfaceExtendingClassWithProtecteds.types create mode 100644 tests/baselines/reference/implementsClauseAlreadySeen.symbols create mode 100644 tests/baselines/reference/implementsClauseAlreadySeen.types create mode 100644 tests/baselines/reference/implicitAnyAmbients.symbols create mode 100644 tests/baselines/reference/implicitAnyAmbients.types create mode 100644 tests/baselines/reference/implicitAnyCastedValue.symbols create mode 100644 tests/baselines/reference/implicitAnyCastedValue.types create mode 100644 tests/baselines/reference/implicitAnyDeclareFunctionExprWithoutFormalType.symbols create mode 100644 tests/baselines/reference/implicitAnyDeclareFunctionExprWithoutFormalType.types create mode 100644 tests/baselines/reference/implicitAnyDeclareFunctionWithoutFormalType.symbols create mode 100644 tests/baselines/reference/implicitAnyDeclareFunctionWithoutFormalType.types create mode 100644 tests/baselines/reference/implicitAnyDeclareMemberWithoutType.symbols create mode 100644 tests/baselines/reference/implicitAnyDeclareMemberWithoutType.types create mode 100644 tests/baselines/reference/implicitAnyDeclareMemberWithoutType2.symbols create mode 100644 tests/baselines/reference/implicitAnyDeclareMemberWithoutType2.types create mode 100644 tests/baselines/reference/implicitAnyDeclareTypePropertyWithoutType.symbols create mode 100644 tests/baselines/reference/implicitAnyDeclareTypePropertyWithoutType.types create mode 100644 tests/baselines/reference/implicitAnyDeclareVariablesWithoutTypeAndInit.symbols create mode 100644 tests/baselines/reference/implicitAnyDeclareVariablesWithoutTypeAndInit.types create mode 100644 tests/baselines/reference/implicitAnyFromCircularInference.symbols create mode 100644 tests/baselines/reference/implicitAnyFromCircularInference.types create mode 100644 tests/baselines/reference/implicitAnyFunctionInvocationWithAnyArguements.symbols create mode 100644 tests/baselines/reference/implicitAnyFunctionInvocationWithAnyArguements.types create mode 100644 tests/baselines/reference/implicitAnyFunctionOverloadWithImplicitAnyReturnType.symbols create mode 100644 tests/baselines/reference/implicitAnyFunctionOverloadWithImplicitAnyReturnType.types create mode 100644 tests/baselines/reference/implicitAnyFunctionReturnNullOrUndefined.symbols create mode 100644 tests/baselines/reference/implicitAnyFunctionReturnNullOrUndefined.types create mode 100644 tests/baselines/reference/implicitAnyGetAndSetAccessorWithAnyReturnType.symbols create mode 100644 tests/baselines/reference/implicitAnyGetAndSetAccessorWithAnyReturnType.types create mode 100644 tests/baselines/reference/implicitAnyInAmbientDeclaration.symbols create mode 100644 tests/baselines/reference/implicitAnyInAmbientDeclaration.types create mode 100644 tests/baselines/reference/implicitAnyInAmbientDeclaration2.d.symbols create mode 100644 tests/baselines/reference/implicitAnyInAmbientDeclaration2.d.types create mode 100644 tests/baselines/reference/implicitAnyNewExprLackConstructorSignature.symbols create mode 100644 tests/baselines/reference/implicitAnyNewExprLackConstructorSignature.types create mode 100644 tests/baselines/reference/implicitAnyWidenToAny.symbols create mode 100644 tests/baselines/reference/implicitAnyWidenToAny.types create mode 100644 tests/baselines/reference/implicitConstParameters.symbols create mode 100644 tests/baselines/reference/implicitConstParameters.types create mode 100644 tests/baselines/reference/importAnImport.symbols create mode 100644 tests/baselines/reference/importAnImport.types create mode 100644 tests/baselines/reference/importAndVariableDeclarationConflict1.symbols create mode 100644 tests/baselines/reference/importAndVariableDeclarationConflict1.types create mode 100644 tests/baselines/reference/importAndVariableDeclarationConflict3.symbols create mode 100644 tests/baselines/reference/importAndVariableDeclarationConflict3.types create mode 100644 tests/baselines/reference/importAndVariableDeclarationConflict4.symbols create mode 100644 tests/baselines/reference/importAndVariableDeclarationConflict4.types create mode 100644 tests/baselines/reference/importAsBaseClass.symbols create mode 100644 tests/baselines/reference/importAsBaseClass.types create mode 100644 tests/baselines/reference/importCallExpression5ESNext.symbols create mode 100644 tests/baselines/reference/importCallExpression5ESNext.types create mode 100644 tests/baselines/reference/importCallExpression6ESNext.symbols create mode 100644 tests/baselines/reference/importCallExpression6ESNext.types create mode 100644 tests/baselines/reference/importCallExpressionCheckReturntype1.symbols create mode 100644 tests/baselines/reference/importCallExpressionCheckReturntype1.types create mode 100644 tests/baselines/reference/importCallExpressionDeclarationEmit2.symbols create mode 100644 tests/baselines/reference/importCallExpressionDeclarationEmit2.types create mode 100644 tests/baselines/reference/importCallExpressionErrorInES2015.symbols create mode 100644 tests/baselines/reference/importCallExpressionErrorInES2015.types create mode 100644 tests/baselines/reference/importCallExpressionGrammarError.symbols create mode 100644 tests/baselines/reference/importCallExpressionGrammarError.types create mode 100644 tests/baselines/reference/importCallExpressionInScriptContext2.symbols create mode 100644 tests/baselines/reference/importCallExpressionInScriptContext2.types create mode 100644 tests/baselines/reference/importCallExpressionIncorrect1.symbols create mode 100644 tests/baselines/reference/importCallExpressionIncorrect1.types create mode 100644 tests/baselines/reference/importCallExpressionIncorrect2.symbols create mode 100644 tests/baselines/reference/importCallExpressionIncorrect2.types create mode 100644 tests/baselines/reference/importCallExpressionNoModuleKindSpecified.symbols create mode 100644 tests/baselines/reference/importCallExpressionNoModuleKindSpecified.types create mode 100644 tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.symbols create mode 100644 tests/baselines/reference/importCallExpressionSpecifierNotStringTypeError.types create mode 100644 tests/baselines/reference/importCallExpressionWithTypeArgument.symbols create mode 100644 tests/baselines/reference/importCallExpressionWithTypeArgument.types create mode 100644 tests/baselines/reference/importDeclRefereingExternalModuleWithNoResolve.symbols create mode 100644 tests/baselines/reference/importDeclRefereingExternalModuleWithNoResolve.types create mode 100644 tests/baselines/reference/importDeclTypes.symbols create mode 100644 tests/baselines/reference/importDeclTypes.types create mode 100644 tests/baselines/reference/importDeclWithClassModifiers.symbols create mode 100644 tests/baselines/reference/importDeclWithClassModifiers.types create mode 100644 tests/baselines/reference/importDeclWithDeclareModifier.symbols create mode 100644 tests/baselines/reference/importDeclWithDeclareModifier.types create mode 100644 tests/baselines/reference/importDeclWithDeclareModifierInAmbientContext.symbols create mode 100644 tests/baselines/reference/importDeclWithDeclareModifierInAmbientContext.types create mode 100644 tests/baselines/reference/importDeclWithExportModifier.symbols create mode 100644 tests/baselines/reference/importDeclWithExportModifier.types create mode 100644 tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.symbols create mode 100644 tests/baselines/reference/importDeclWithExportModifierAndExportAssignment.types create mode 100644 tests/baselines/reference/importDeclWithExportModifierAndExportAssignmentInAmbientContext.symbols create mode 100644 tests/baselines/reference/importDeclWithExportModifierAndExportAssignmentInAmbientContext.types create mode 100644 tests/baselines/reference/importDeclarationInModuleDeclaration1.symbols create mode 100644 tests/baselines/reference/importDeclarationInModuleDeclaration1.types create mode 100644 tests/baselines/reference/importHelpersInIsolatedModules.symbols create mode 100644 tests/baselines/reference/importHelpersInIsolatedModules.types create mode 100644 tests/baselines/reference/importHelpersNoHelpers.symbols create mode 100644 tests/baselines/reference/importHelpersNoHelpers.types create mode 100644 tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.symbols create mode 100644 tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types create mode 100644 tests/baselines/reference/importHelpersNoModule.symbols create mode 100644 tests/baselines/reference/importHelpersNoModule.types create mode 100644 tests/baselines/reference/importInsideModule.symbols create mode 100644 tests/baselines/reference/importInsideModule.types create mode 100644 tests/baselines/reference/importNonExternalModule.symbols create mode 100644 tests/baselines/reference/importNonExternalModule.types create mode 100644 tests/baselines/reference/importNonStringLiteral.symbols create mode 100644 tests/baselines/reference/importNonStringLiteral.types create mode 100644 tests/baselines/reference/importStatementsInterfaces.symbols create mode 100644 tests/baselines/reference/importStatementsInterfaces.types create mode 100644 tests/baselines/reference/importTsBeforeDTs.symbols create mode 100644 tests/baselines/reference/importTsBeforeDTs.types create mode 100644 tests/baselines/reference/importWithTrailingSlash_noResolve.symbols create mode 100644 tests/baselines/reference/importWithTrailingSlash_noResolve.types create mode 100644 tests/baselines/reference/importedModuleAddToGlobal.symbols create mode 100644 tests/baselines/reference/importedModuleAddToGlobal.types create mode 100644 tests/baselines/reference/importsImplicitlyReadonly.symbols create mode 100644 tests/baselines/reference/importsImplicitlyReadonly.types create mode 100644 tests/baselines/reference/inOperator.symbols create mode 100644 tests/baselines/reference/inOperator.types create mode 100644 tests/baselines/reference/inOperatorWithInvalidOperands.symbols create mode 100644 tests/baselines/reference/inOperatorWithInvalidOperands.types create mode 100644 tests/baselines/reference/incompatibleAssignmentOfIdenticallyNamedTypes.symbols create mode 100644 tests/baselines/reference/incompatibleAssignmentOfIdenticallyNamedTypes.types create mode 100644 tests/baselines/reference/incompatibleExports1.symbols create mode 100644 tests/baselines/reference/incompatibleExports1.types create mode 100644 tests/baselines/reference/incompatibleExports2.symbols create mode 100644 tests/baselines/reference/incompatibleExports2.types create mode 100644 tests/baselines/reference/incompatibleGenericTypes.symbols create mode 100644 tests/baselines/reference/incompatibleGenericTypes.types create mode 100644 tests/baselines/reference/incompatibleTypes.symbols create mode 100644 tests/baselines/reference/incompatibleTypes.types create mode 100644 tests/baselines/reference/incompleteDottedExpressionAtEOF.symbols create mode 100644 tests/baselines/reference/incompleteDottedExpressionAtEOF.types create mode 100644 tests/baselines/reference/incompleteObjectLiteral1.symbols create mode 100644 tests/baselines/reference/incompleteObjectLiteral1.types create mode 100644 tests/baselines/reference/incorrectClassOverloadChain.symbols create mode 100644 tests/baselines/reference/incorrectClassOverloadChain.types create mode 100644 tests/baselines/reference/incrementAndDecrement.symbols create mode 100644 tests/baselines/reference/incrementAndDecrement.types create mode 100644 tests/baselines/reference/incrementOnTypeParameter.symbols create mode 100644 tests/baselines/reference/incrementOnTypeParameter.types create mode 100644 tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.symbols create mode 100644 tests/baselines/reference/incrementOperatorWithAnyOtherTypeInvalidOperations.types create mode 100644 tests/baselines/reference/incrementOperatorWithEnumType.symbols create mode 100644 tests/baselines/reference/incrementOperatorWithEnumType.types create mode 100644 tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.symbols create mode 100644 tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.types create mode 100644 tests/baselines/reference/incrementOperatorWithNumberTypeInvalidOperations.symbols create mode 100644 tests/baselines/reference/incrementOperatorWithNumberTypeInvalidOperations.types create mode 100644 tests/baselines/reference/incrementOperatorWithUnsupportedBooleanType.symbols create mode 100644 tests/baselines/reference/incrementOperatorWithUnsupportedBooleanType.types create mode 100644 tests/baselines/reference/incrementOperatorWithUnsupportedStringType.symbols create mode 100644 tests/baselines/reference/incrementOperatorWithUnsupportedStringType.types create mode 100644 tests/baselines/reference/indexIntoArraySubclass.symbols create mode 100644 tests/baselines/reference/indexIntoArraySubclass.types create mode 100644 tests/baselines/reference/indexSignatureAndMappedType.symbols create mode 100644 tests/baselines/reference/indexSignatureAndMappedType.types create mode 100644 tests/baselines/reference/indexSignatureMustHaveTypeAnnotation.symbols create mode 100644 tests/baselines/reference/indexSignatureMustHaveTypeAnnotation.types create mode 100644 tests/baselines/reference/indexSignatureTypeCheck.symbols create mode 100644 tests/baselines/reference/indexSignatureTypeCheck.types create mode 100644 tests/baselines/reference/indexSignatureTypeCheck2.symbols create mode 100644 tests/baselines/reference/indexSignatureTypeCheck2.types create mode 100644 tests/baselines/reference/indexSignatureTypeInference.symbols create mode 100644 tests/baselines/reference/indexSignatureTypeInference.types create mode 100644 tests/baselines/reference/indexSignatureWithAccessibilityModifier.symbols create mode 100644 tests/baselines/reference/indexSignatureWithAccessibilityModifier.types create mode 100644 tests/baselines/reference/indexSignatureWithInitializer.symbols create mode 100644 tests/baselines/reference/indexSignatureWithInitializer.types create mode 100644 tests/baselines/reference/indexSignatureWithInitializer1.symbols create mode 100644 tests/baselines/reference/indexSignatureWithInitializer1.types create mode 100644 tests/baselines/reference/indexSignatureWithoutTypeAnnotation1.symbols create mode 100644 tests/baselines/reference/indexSignatureWithoutTypeAnnotation1.types create mode 100644 tests/baselines/reference/indexTypeCheck.symbols create mode 100644 tests/baselines/reference/indexTypeCheck.types create mode 100644 tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.symbols create mode 100644 tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.types create mode 100644 tests/baselines/reference/indexWithoutParamType.symbols create mode 100644 tests/baselines/reference/indexWithoutParamType.types create mode 100644 tests/baselines/reference/indexWithoutParamType2.symbols create mode 100644 tests/baselines/reference/indexWithoutParamType2.types create mode 100644 tests/baselines/reference/indexer2A.symbols create mode 100644 tests/baselines/reference/indexer2A.types create mode 100644 tests/baselines/reference/indexerAsOptional.symbols create mode 100644 tests/baselines/reference/indexerAsOptional.types create mode 100644 tests/baselines/reference/indexerConstraints.symbols create mode 100644 tests/baselines/reference/indexerConstraints.types create mode 100644 tests/baselines/reference/indexerConstraints2.symbols create mode 100644 tests/baselines/reference/indexerConstraints2.types create mode 100644 tests/baselines/reference/indexerSignatureWithRestParam.symbols create mode 100644 tests/baselines/reference/indexerSignatureWithRestParam.types create mode 100644 tests/baselines/reference/indirectSelfReference.symbols create mode 100644 tests/baselines/reference/indirectSelfReference.types create mode 100644 tests/baselines/reference/indirectSelfReferenceGeneric.symbols create mode 100644 tests/baselines/reference/indirectSelfReferenceGeneric.types create mode 100644 tests/baselines/reference/inferFromGenericFunctionReturnTypes1.symbols create mode 100644 tests/baselines/reference/inferFromGenericFunctionReturnTypes1.types create mode 100644 tests/baselines/reference/inferSetterParamType.symbols create mode 100644 tests/baselines/reference/inferSetterParamType.types create mode 100644 tests/baselines/reference/inferentialTypingWithObjectLiteralProperties.symbols create mode 100644 tests/baselines/reference/inferentialTypingWithObjectLiteralProperties.types create mode 100644 tests/baselines/reference/infiniteExpansionThroughInstantiation.symbols create mode 100644 tests/baselines/reference/infiniteExpansionThroughInstantiation.types create mode 100644 tests/baselines/reference/infinitelyExpandingOverloads.symbols create mode 100644 tests/baselines/reference/infinitelyExpandingOverloads.types create mode 100644 tests/baselines/reference/infinitelyExpandingTypes1.symbols create mode 100644 tests/baselines/reference/infinitelyExpandingTypes1.types create mode 100644 tests/baselines/reference/infinitelyExpandingTypes2.symbols create mode 100644 tests/baselines/reference/infinitelyExpandingTypes2.types create mode 100644 tests/baselines/reference/inheritFromGenericTypeParameter.symbols create mode 100644 tests/baselines/reference/inheritFromGenericTypeParameter.types create mode 100644 tests/baselines/reference/inheritSameNamePrivatePropertiesFromDifferentOrigins.symbols create mode 100644 tests/baselines/reference/inheritSameNamePrivatePropertiesFromDifferentOrigins.types create mode 100644 tests/baselines/reference/inheritSameNamePropertiesWithDifferentOptionality.symbols create mode 100644 tests/baselines/reference/inheritSameNamePropertiesWithDifferentOptionality.types create mode 100644 tests/baselines/reference/inheritSameNamePropertiesWithDifferentVisibility.symbols create mode 100644 tests/baselines/reference/inheritSameNamePropertiesWithDifferentVisibility.types create mode 100644 tests/baselines/reference/inheritance.symbols create mode 100644 tests/baselines/reference/inheritance.types create mode 100644 tests/baselines/reference/inheritance1.symbols create mode 100644 tests/baselines/reference/inheritance1.types create mode 100644 tests/baselines/reference/inheritanceGrandParentPrivateMemberCollision.symbols create mode 100644 tests/baselines/reference/inheritanceGrandParentPrivateMemberCollision.types create mode 100644 tests/baselines/reference/inheritanceGrandParentPrivateMemberCollisionWithPublicMember.symbols create mode 100644 tests/baselines/reference/inheritanceGrandParentPrivateMemberCollisionWithPublicMember.types create mode 100644 tests/baselines/reference/inheritanceGrandParentPublicMemberCollisionWithPrivateMember.symbols create mode 100644 tests/baselines/reference/inheritanceGrandParentPublicMemberCollisionWithPrivateMember.types create mode 100644 tests/baselines/reference/inheritanceMemberAccessorOverridingAccessor.symbols create mode 100644 tests/baselines/reference/inheritanceMemberAccessorOverridingAccessor.types create mode 100644 tests/baselines/reference/inheritanceMemberAccessorOverridingMethod.symbols create mode 100644 tests/baselines/reference/inheritanceMemberAccessorOverridingMethod.types create mode 100644 tests/baselines/reference/inheritanceMemberAccessorOverridingProperty.symbols create mode 100644 tests/baselines/reference/inheritanceMemberAccessorOverridingProperty.types create mode 100644 tests/baselines/reference/inheritanceMemberFuncOverridingAccessor.symbols create mode 100644 tests/baselines/reference/inheritanceMemberFuncOverridingAccessor.types create mode 100644 tests/baselines/reference/inheritanceMemberFuncOverridingProperty.symbols create mode 100644 tests/baselines/reference/inheritanceMemberFuncOverridingProperty.types create mode 100644 tests/baselines/reference/inheritanceMemberPropertyOverridingAccessor.symbols create mode 100644 tests/baselines/reference/inheritanceMemberPropertyOverridingAccessor.types create mode 100644 tests/baselines/reference/inheritanceMemberPropertyOverridingMethod.symbols create mode 100644 tests/baselines/reference/inheritanceMemberPropertyOverridingMethod.types create mode 100644 tests/baselines/reference/inheritanceStaticAccessorOverridingAccessor.symbols create mode 100644 tests/baselines/reference/inheritanceStaticAccessorOverridingAccessor.types create mode 100644 tests/baselines/reference/inheritanceStaticAccessorOverridingMethod.symbols create mode 100644 tests/baselines/reference/inheritanceStaticAccessorOverridingMethod.types create mode 100644 tests/baselines/reference/inheritanceStaticAccessorOverridingProperty.symbols create mode 100644 tests/baselines/reference/inheritanceStaticAccessorOverridingProperty.types create mode 100644 tests/baselines/reference/inheritanceStaticFuncOverridingAccessor.symbols create mode 100644 tests/baselines/reference/inheritanceStaticFuncOverridingAccessor.types create mode 100644 tests/baselines/reference/inheritanceStaticFuncOverridingAccessorOfFuncType.symbols create mode 100644 tests/baselines/reference/inheritanceStaticFuncOverridingAccessorOfFuncType.types create mode 100644 tests/baselines/reference/inheritanceStaticFuncOverridingProperty.symbols create mode 100644 tests/baselines/reference/inheritanceStaticFuncOverridingProperty.types create mode 100644 tests/baselines/reference/inheritanceStaticMembersIncompatible.symbols create mode 100644 tests/baselines/reference/inheritanceStaticMembersIncompatible.types create mode 100644 tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.symbols create mode 100644 tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.types create mode 100644 tests/baselines/reference/inheritanceStaticPropertyOverridingMethod.symbols create mode 100644 tests/baselines/reference/inheritanceStaticPropertyOverridingMethod.types create mode 100644 tests/baselines/reference/inheritedConstructorWithRestParams.symbols create mode 100644 tests/baselines/reference/inheritedConstructorWithRestParams.types create mode 100644 tests/baselines/reference/inheritedConstructorWithRestParams2.symbols create mode 100644 tests/baselines/reference/inheritedConstructorWithRestParams2.types create mode 100644 tests/baselines/reference/inheritedMembersAndIndexSignaturesFromDifferentBases.symbols create mode 100644 tests/baselines/reference/inheritedMembersAndIndexSignaturesFromDifferentBases.types create mode 100644 tests/baselines/reference/inheritedModuleMembersForClodule.symbols create mode 100644 tests/baselines/reference/inheritedModuleMembersForClodule.types create mode 100644 tests/baselines/reference/inheritedStringIndexersFromDifferentBaseTypes.symbols create mode 100644 tests/baselines/reference/inheritedStringIndexersFromDifferentBaseTypes.types create mode 100644 tests/baselines/reference/inheritedStringIndexersFromDifferentBaseTypes2.symbols create mode 100644 tests/baselines/reference/inheritedStringIndexersFromDifferentBaseTypes2.types create mode 100644 tests/baselines/reference/initializerReferencingConstructorLocals.symbols create mode 100644 tests/baselines/reference/initializerReferencingConstructorLocals.types create mode 100644 tests/baselines/reference/initializerReferencingConstructorParameters.symbols create mode 100644 tests/baselines/reference/initializerReferencingConstructorParameters.types create mode 100644 tests/baselines/reference/initializersInDeclarations.symbols create mode 100644 tests/baselines/reference/initializersInDeclarations.types create mode 100644 tests/baselines/reference/inlineSourceMap.symbols create mode 100644 tests/baselines/reference/inlineSourceMap.types create mode 100644 tests/baselines/reference/inlineSourceMap2.symbols create mode 100644 tests/baselines/reference/inlineSourceMap2.types create mode 100644 tests/baselines/reference/inlineSources.symbols create mode 100644 tests/baselines/reference/inlineSources.types create mode 100644 tests/baselines/reference/inlineSources2.symbols create mode 100644 tests/baselines/reference/inlineSources2.types create mode 100644 tests/baselines/reference/innerAliases.symbols create mode 100644 tests/baselines/reference/innerAliases.types create mode 100644 tests/baselines/reference/innerModExport1.symbols create mode 100644 tests/baselines/reference/innerModExport1.types create mode 100644 tests/baselines/reference/innerModExport2.symbols create mode 100644 tests/baselines/reference/innerModExport2.types create mode 100644 tests/baselines/reference/innerTypeCheckOfLambdaArgument.symbols create mode 100644 tests/baselines/reference/innerTypeCheckOfLambdaArgument.types create mode 100644 tests/baselines/reference/instanceMemberAssignsToClassPrototype.symbols create mode 100644 tests/baselines/reference/instanceMemberAssignsToClassPrototype.types create mode 100644 tests/baselines/reference/instancePropertiesInheritedIntoClassType.symbols create mode 100644 tests/baselines/reference/instancePropertiesInheritedIntoClassType.types create mode 100644 tests/baselines/reference/instancePropertyInClassType.symbols create mode 100644 tests/baselines/reference/instancePropertyInClassType.types create mode 100644 tests/baselines/reference/instanceSubtypeCheck2.symbols create mode 100644 tests/baselines/reference/instanceSubtypeCheck2.types create mode 100644 tests/baselines/reference/instanceofOperator.symbols create mode 100644 tests/baselines/reference/instanceofOperator.types create mode 100644 tests/baselines/reference/instanceofOperatorWithInvalidOperands.symbols create mode 100644 tests/baselines/reference/instanceofOperatorWithInvalidOperands.types create mode 100644 tests/baselines/reference/instantiateGenericClassWithWrongNumberOfTypeArguments.symbols create mode 100644 tests/baselines/reference/instantiateGenericClassWithWrongNumberOfTypeArguments.types create mode 100644 tests/baselines/reference/instantiateNonGenericTypeWithTypeArguments.symbols create mode 100644 tests/baselines/reference/instantiateNonGenericTypeWithTypeArguments.types create mode 100644 tests/baselines/reference/instantiateTypeParameter.symbols create mode 100644 tests/baselines/reference/instantiateTypeParameter.types create mode 100644 tests/baselines/reference/intTypeCheck.symbols create mode 100644 tests/baselines/reference/intTypeCheck.types create mode 100644 tests/baselines/reference/interfaceAssignmentCompat.symbols create mode 100644 tests/baselines/reference/interfaceAssignmentCompat.types create mode 100644 tests/baselines/reference/interfaceDeclaration1.symbols create mode 100644 tests/baselines/reference/interfaceDeclaration1.types create mode 100644 tests/baselines/reference/interfaceDeclaration3.symbols create mode 100644 tests/baselines/reference/interfaceDeclaration3.types create mode 100644 tests/baselines/reference/interfaceDeclaration4.symbols create mode 100644 tests/baselines/reference/interfaceDeclaration4.types create mode 100644 tests/baselines/reference/interfaceDeclaration6.symbols create mode 100644 tests/baselines/reference/interfaceDeclaration6.types create mode 100644 tests/baselines/reference/interfaceExtendingClass.symbols create mode 100644 tests/baselines/reference/interfaceExtendingClass.types create mode 100644 tests/baselines/reference/interfaceExtendingClass2.symbols create mode 100644 tests/baselines/reference/interfaceExtendingClass2.types create mode 100644 tests/baselines/reference/interfaceExtendingClassWithPrivates.symbols create mode 100644 tests/baselines/reference/interfaceExtendingClassWithPrivates.types create mode 100644 tests/baselines/reference/interfaceExtendingClassWithPrivates2.symbols create mode 100644 tests/baselines/reference/interfaceExtendingClassWithPrivates2.types create mode 100644 tests/baselines/reference/interfaceExtendingClassWithProtecteds.symbols create mode 100644 tests/baselines/reference/interfaceExtendingClassWithProtecteds.types create mode 100644 tests/baselines/reference/interfaceExtendingClassWithProtecteds2.symbols create mode 100644 tests/baselines/reference/interfaceExtendingClassWithProtecteds2.types create mode 100644 tests/baselines/reference/interfaceExtendsClassWithPrivate1.symbols create mode 100644 tests/baselines/reference/interfaceExtendsClassWithPrivate1.types create mode 100644 tests/baselines/reference/interfaceExtendsClassWithPrivate2.symbols create mode 100644 tests/baselines/reference/interfaceExtendsClassWithPrivate2.types create mode 100644 tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.symbols create mode 100644 tests/baselines/reference/interfaceExtendsObjectIntersectionErrors.types create mode 100644 tests/baselines/reference/interfaceImplementation1.symbols create mode 100644 tests/baselines/reference/interfaceImplementation1.types create mode 100644 tests/baselines/reference/interfaceImplementation2.symbols create mode 100644 tests/baselines/reference/interfaceImplementation2.types create mode 100644 tests/baselines/reference/interfaceImplementation3.symbols create mode 100644 tests/baselines/reference/interfaceImplementation3.types create mode 100644 tests/baselines/reference/interfaceImplementation4.symbols create mode 100644 tests/baselines/reference/interfaceImplementation4.types create mode 100644 tests/baselines/reference/interfaceImplementation5.symbols create mode 100644 tests/baselines/reference/interfaceImplementation5.types create mode 100644 tests/baselines/reference/interfaceImplementation6.symbols create mode 100644 tests/baselines/reference/interfaceImplementation6.types create mode 100644 tests/baselines/reference/interfaceImplementation7.symbols create mode 100644 tests/baselines/reference/interfaceImplementation7.types create mode 100644 tests/baselines/reference/interfaceImplementation8.symbols create mode 100644 tests/baselines/reference/interfaceImplementation8.types create mode 100644 tests/baselines/reference/interfaceInheritance.symbols create mode 100644 tests/baselines/reference/interfaceInheritance.types create mode 100644 tests/baselines/reference/interfaceMayNotBeExtendedWitACall.symbols create mode 100644 tests/baselines/reference/interfaceMayNotBeExtendedWitACall.types create mode 100644 tests/baselines/reference/interfaceMemberValidation.symbols create mode 100644 tests/baselines/reference/interfaceMemberValidation.types create mode 100644 tests/baselines/reference/interfaceNameAsIdentifier.symbols create mode 100644 tests/baselines/reference/interfaceNameAsIdentifier.types create mode 100644 tests/baselines/reference/interfaceNaming1.symbols create mode 100644 tests/baselines/reference/interfaceNaming1.types create mode 100644 tests/baselines/reference/interfacePropertiesWithSameName2.symbols create mode 100644 tests/baselines/reference/interfacePropertiesWithSameName2.types create mode 100644 tests/baselines/reference/interfacePropertiesWithSameName3.symbols create mode 100644 tests/baselines/reference/interfacePropertiesWithSameName3.types create mode 100644 tests/baselines/reference/interfaceThatHidesBaseProperty2.symbols create mode 100644 tests/baselines/reference/interfaceThatHidesBaseProperty2.types create mode 100644 tests/baselines/reference/interfaceThatIndirectlyInheritsFromItself.symbols create mode 100644 tests/baselines/reference/interfaceThatIndirectlyInheritsFromItself.types create mode 100644 tests/baselines/reference/interfaceThatInheritsFromItself.symbols create mode 100644 tests/baselines/reference/interfaceThatInheritsFromItself.types create mode 100644 tests/baselines/reference/interfaceWithAccessibilityModifiers.symbols create mode 100644 tests/baselines/reference/interfaceWithAccessibilityModifiers.types create mode 100644 tests/baselines/reference/interfaceWithImplements1.symbols create mode 100644 tests/baselines/reference/interfaceWithImplements1.types create mode 100644 tests/baselines/reference/interfaceWithMultipleBaseTypes.symbols create mode 100644 tests/baselines/reference/interfaceWithMultipleBaseTypes.types create mode 100644 tests/baselines/reference/interfaceWithMultipleBaseTypes2.symbols create mode 100644 tests/baselines/reference/interfaceWithMultipleBaseTypes2.types create mode 100644 tests/baselines/reference/interfaceWithMultipleDeclarations.symbols create mode 100644 tests/baselines/reference/interfaceWithMultipleDeclarations.types create mode 100644 tests/baselines/reference/interfaceWithPrivateMember.symbols create mode 100644 tests/baselines/reference/interfaceWithPrivateMember.types create mode 100644 tests/baselines/reference/interfaceWithPropertyThatIsPrivateInBaseType.symbols create mode 100644 tests/baselines/reference/interfaceWithPropertyThatIsPrivateInBaseType.types create mode 100644 tests/baselines/reference/interfaceWithPropertyThatIsPrivateInBaseType2.symbols create mode 100644 tests/baselines/reference/interfaceWithPropertyThatIsPrivateInBaseType2.types create mode 100644 tests/baselines/reference/interfaceWithStringIndexerHidingBaseTypeIndexer.symbols create mode 100644 tests/baselines/reference/interfaceWithStringIndexerHidingBaseTypeIndexer.types create mode 100644 tests/baselines/reference/interfaceWithStringIndexerHidingBaseTypeIndexer2.symbols create mode 100644 tests/baselines/reference/interfaceWithStringIndexerHidingBaseTypeIndexer2.types create mode 100644 tests/baselines/reference/interfaceWithStringIndexerHidingBaseTypeIndexer3.symbols create mode 100644 tests/baselines/reference/interfaceWithStringIndexerHidingBaseTypeIndexer3.types create mode 100644 tests/baselines/reference/interfacedeclWithIndexerErrors.symbols create mode 100644 tests/baselines/reference/interfacedeclWithIndexerErrors.types create mode 100644 tests/baselines/reference/interfacesWithPredefinedTypesAsNames.symbols create mode 100644 tests/baselines/reference/interfacesWithPredefinedTypesAsNames.types create mode 100644 tests/baselines/reference/internalAliasClassInsideLocalModuleWithoutExportAccessError.symbols create mode 100644 tests/baselines/reference/internalAliasClassInsideLocalModuleWithoutExportAccessError.types create mode 100644 tests/baselines/reference/internalAliasEnumInsideLocalModuleWithoutExportAccessError.symbols create mode 100644 tests/baselines/reference/internalAliasEnumInsideLocalModuleWithoutExportAccessError.types create mode 100644 tests/baselines/reference/internalAliasFunctionInsideLocalModuleWithoutExportAccessError.symbols create mode 100644 tests/baselines/reference/internalAliasFunctionInsideLocalModuleWithoutExportAccessError.types create mode 100644 tests/baselines/reference/internalAliasInitializedModuleInsideLocalModuleWithoutExportAccessError.symbols create mode 100644 tests/baselines/reference/internalAliasInitializedModuleInsideLocalModuleWithoutExportAccessError.types create mode 100644 tests/baselines/reference/internalAliasInterfaceInsideLocalModuleWithoutExportAccessError.symbols create mode 100644 tests/baselines/reference/internalAliasInterfaceInsideLocalModuleWithoutExportAccessError.types create mode 100644 tests/baselines/reference/internalAliasUninitializedModuleInsideLocalModuleWithoutExportAccessError.symbols create mode 100644 tests/baselines/reference/internalAliasUninitializedModuleInsideLocalModuleWithoutExportAccessError.types create mode 100644 tests/baselines/reference/internalAliasVarInsideLocalModuleWithoutExportAccessError.symbols create mode 100644 tests/baselines/reference/internalAliasVarInsideLocalModuleWithoutExportAccessError.types create mode 100644 tests/baselines/reference/internalImportInstantiatedModuleMergedWithClassNotReferencingInstance.symbols create mode 100644 tests/baselines/reference/internalImportInstantiatedModuleMergedWithClassNotReferencingInstance.types create mode 100644 tests/baselines/reference/internalImportInstantiatedModuleNotReferencingInstance.symbols create mode 100644 tests/baselines/reference/internalImportInstantiatedModuleNotReferencingInstance.types create mode 100644 tests/baselines/reference/internalImportUnInstantiatedModuleMergedWithClassNotReferencingInstance.symbols create mode 100644 tests/baselines/reference/internalImportUnInstantiatedModuleMergedWithClassNotReferencingInstance.types create mode 100644 tests/baselines/reference/intersectionAndUnionTypes.symbols create mode 100644 tests/baselines/reference/intersectionAndUnionTypes.types create mode 100644 tests/baselines/reference/intersectionTypeAssignment.symbols create mode 100644 tests/baselines/reference/intersectionTypeAssignment.types create mode 100644 tests/baselines/reference/intersectionTypeInference.symbols create mode 100644 tests/baselines/reference/intersectionTypeInference.types create mode 100644 tests/baselines/reference/intersectionTypeReadonly.symbols create mode 100644 tests/baselines/reference/intersectionTypeReadonly.types create mode 100644 tests/baselines/reference/intrinsics.symbols create mode 100644 tests/baselines/reference/intrinsics.types create mode 100644 tests/baselines/reference/invalidAssignmentsToVoid.symbols create mode 100644 tests/baselines/reference/invalidAssignmentsToVoid.types create mode 100644 tests/baselines/reference/invalidBinaryIntegerLiteralAndOctalIntegerLiteral.symbols create mode 100644 tests/baselines/reference/invalidBinaryIntegerLiteralAndOctalIntegerLiteral.types create mode 100644 tests/baselines/reference/invalidBooleanAssignments.symbols create mode 100644 tests/baselines/reference/invalidBooleanAssignments.types create mode 100644 tests/baselines/reference/invalidConstraint1.symbols create mode 100644 tests/baselines/reference/invalidConstraint1.types create mode 100644 tests/baselines/reference/invalidContinueInDownlevelAsync.symbols create mode 100644 tests/baselines/reference/invalidContinueInDownlevelAsync.types create mode 100644 tests/baselines/reference/invalidDoWhileBreakStatements.symbols create mode 100644 tests/baselines/reference/invalidDoWhileBreakStatements.types create mode 100644 tests/baselines/reference/invalidDoWhileContinueStatements.symbols create mode 100644 tests/baselines/reference/invalidDoWhileContinueStatements.types create mode 100644 tests/baselines/reference/invalidEnumAssignments.symbols create mode 100644 tests/baselines/reference/invalidEnumAssignments.types create mode 100644 tests/baselines/reference/invalidForBreakStatements.symbols create mode 100644 tests/baselines/reference/invalidForBreakStatements.types create mode 100644 tests/baselines/reference/invalidForContinueStatements.symbols create mode 100644 tests/baselines/reference/invalidForContinueStatements.types create mode 100644 tests/baselines/reference/invalidForInBreakStatements.symbols create mode 100644 tests/baselines/reference/invalidForInBreakStatements.types create mode 100644 tests/baselines/reference/invalidForInContinueStatements.symbols create mode 100644 tests/baselines/reference/invalidForInContinueStatements.types create mode 100644 tests/baselines/reference/invalidImportAliasIdentifiers.symbols create mode 100644 tests/baselines/reference/invalidImportAliasIdentifiers.types create mode 100644 tests/baselines/reference/invalidInstantiatedModule.symbols create mode 100644 tests/baselines/reference/invalidInstantiatedModule.types create mode 100644 tests/baselines/reference/invalidLetInForOfAndForIn_ES5.symbols create mode 100644 tests/baselines/reference/invalidLetInForOfAndForIn_ES5.types create mode 100644 tests/baselines/reference/invalidLetInForOfAndForIn_ES6.symbols create mode 100644 tests/baselines/reference/invalidLetInForOfAndForIn_ES6.types create mode 100644 tests/baselines/reference/invalidModuleWithStatementsOfEveryKind.symbols create mode 100644 tests/baselines/reference/invalidModuleWithStatementsOfEveryKind.types create mode 100644 tests/baselines/reference/invalidModuleWithVarStatements.symbols create mode 100644 tests/baselines/reference/invalidModuleWithVarStatements.types create mode 100644 tests/baselines/reference/invalidMultipleVariableDeclarations.symbols create mode 100644 tests/baselines/reference/invalidMultipleVariableDeclarations.types create mode 100644 tests/baselines/reference/invalidNestedModules.symbols create mode 100644 tests/baselines/reference/invalidNestedModules.types create mode 100644 tests/baselines/reference/invalidNewTarget.es5.symbols create mode 100644 tests/baselines/reference/invalidNewTarget.es5.types create mode 100644 tests/baselines/reference/invalidNewTarget.es6.symbols create mode 100644 tests/baselines/reference/invalidNewTarget.es6.types create mode 100644 tests/baselines/reference/invalidNumberAssignments.symbols create mode 100644 tests/baselines/reference/invalidNumberAssignments.types create mode 100644 tests/baselines/reference/invalidReferenceSyntax1.symbols create mode 100644 tests/baselines/reference/invalidReferenceSyntax1.types create mode 100644 tests/baselines/reference/invalidReturnStatements.symbols create mode 100644 tests/baselines/reference/invalidReturnStatements.types create mode 100644 tests/baselines/reference/invalidStaticField.symbols create mode 100644 tests/baselines/reference/invalidStaticField.types create mode 100644 tests/baselines/reference/invalidStringAssignments.symbols create mode 100644 tests/baselines/reference/invalidStringAssignments.types create mode 100644 tests/baselines/reference/invalidSwitchContinueStatement.symbols create mode 100644 tests/baselines/reference/invalidSwitchContinueStatement.types create mode 100644 tests/baselines/reference/invalidSymbolInTypeParameter1.symbols create mode 100644 tests/baselines/reference/invalidSymbolInTypeParameter1.types create mode 100644 tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.symbols create mode 100644 tests/baselines/reference/invalidSyntaxNamespaceImportWithAMD.types create mode 100644 tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.symbols create mode 100644 tests/baselines/reference/invalidSyntaxNamespaceImportWithCommonjs.types create mode 100644 tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.symbols create mode 100644 tests/baselines/reference/invalidSyntaxNamespaceImportWithSystem.types create mode 100644 tests/baselines/reference/invalidThrowStatement.symbols create mode 100644 tests/baselines/reference/invalidThrowStatement.types create mode 100644 tests/baselines/reference/invalidTripleSlashReference.symbols create mode 100644 tests/baselines/reference/invalidTripleSlashReference.types create mode 100644 tests/baselines/reference/invalidTryStatements.symbols create mode 100644 tests/baselines/reference/invalidTryStatements.types create mode 100644 tests/baselines/reference/invalidTryStatements2.symbols create mode 100644 tests/baselines/reference/invalidTryStatements2.types create mode 100644 tests/baselines/reference/invalidTypeOfTarget.symbols create mode 100644 tests/baselines/reference/invalidTypeOfTarget.types create mode 100644 tests/baselines/reference/invalidUndefinedAssignments.symbols create mode 100644 tests/baselines/reference/invalidUndefinedAssignments.types create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance.symbols create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance.types create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance2.symbols create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance2.types create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance3.symbols create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance3.types create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance4.symbols create mode 100644 tests/baselines/reference/invalidUnicodeEscapeSequance4.types create mode 100644 tests/baselines/reference/invalidUseOfTypeAsNamespace.symbols create mode 100644 tests/baselines/reference/invalidUseOfTypeAsNamespace.types create mode 100644 tests/baselines/reference/invalidVoidAssignments.symbols create mode 100644 tests/baselines/reference/invalidVoidAssignments.types create mode 100644 tests/baselines/reference/invalidVoidValues.symbols create mode 100644 tests/baselines/reference/invalidVoidValues.types create mode 100644 tests/baselines/reference/invalidWhileBreakStatements.symbols create mode 100644 tests/baselines/reference/invalidWhileBreakStatements.types create mode 100644 tests/baselines/reference/invalidWhileContinueStatements.symbols create mode 100644 tests/baselines/reference/invalidWhileContinueStatements.types create mode 100644 tests/baselines/reference/invocationExpressionInFunctionParameter.symbols create mode 100644 tests/baselines/reference/invocationExpressionInFunctionParameter.types create mode 100644 tests/baselines/reference/invokingNonGenericMethodWithTypeArguments1.symbols create mode 100644 tests/baselines/reference/invokingNonGenericMethodWithTypeArguments1.types create mode 100644 tests/baselines/reference/invokingNonGenericMethodWithTypeArguments2.symbols create mode 100644 tests/baselines/reference/invokingNonGenericMethodWithTypeArguments2.types create mode 100644 tests/baselines/reference/isolatedModulesAmbientConstEnum.symbols create mode 100644 tests/baselines/reference/isolatedModulesAmbientConstEnum.types create mode 100644 tests/baselines/reference/isolatedModulesDeclaration.symbols create mode 100644 tests/baselines/reference/isolatedModulesDeclaration.types create mode 100644 tests/baselines/reference/isolatedModulesImportExportElision.symbols create mode 100644 tests/baselines/reference/isolatedModulesImportExportElision.types create mode 100644 tests/baselines/reference/isolatedModulesNoEmitOnError.symbols create mode 100644 tests/baselines/reference/isolatedModulesNoEmitOnError.types create mode 100644 tests/baselines/reference/isolatedModulesNoExternalModule.symbols create mode 100644 tests/baselines/reference/isolatedModulesNoExternalModule.types create mode 100644 tests/baselines/reference/isolatedModulesOut.symbols create mode 100644 tests/baselines/reference/isolatedModulesOut.types create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-AMD.symbols create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-AMD.types create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-CommonJS.symbols create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-CommonJS.types create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-ES6.symbols create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-ES6.types create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-System.symbols create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-System.types create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-UMD.symbols create mode 100644 tests/baselines/reference/isolatedModulesPlainFile-UMD.types create mode 100644 tests/baselines/reference/isolatedModulesReExportType.symbols create mode 100644 tests/baselines/reference/isolatedModulesReExportType.types create mode 100644 tests/baselines/reference/iterableArrayPattern10.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern10.types create mode 100644 tests/baselines/reference/iterableArrayPattern14.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern14.types create mode 100644 tests/baselines/reference/iterableArrayPattern15.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern15.types create mode 100644 tests/baselines/reference/iterableArrayPattern16.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern16.types create mode 100644 tests/baselines/reference/iterableArrayPattern17.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern17.types create mode 100644 tests/baselines/reference/iterableArrayPattern18.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern18.types create mode 100644 tests/baselines/reference/iterableArrayPattern19.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern19.types create mode 100644 tests/baselines/reference/iterableArrayPattern20.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern20.types create mode 100644 tests/baselines/reference/iterableArrayPattern21.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern21.types create mode 100644 tests/baselines/reference/iterableArrayPattern22.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern22.types create mode 100644 tests/baselines/reference/iterableArrayPattern23.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern23.types create mode 100644 tests/baselines/reference/iterableArrayPattern24.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern24.types create mode 100644 tests/baselines/reference/iterableArrayPattern25.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern25.types create mode 100644 tests/baselines/reference/iterableArrayPattern26.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern26.types create mode 100644 tests/baselines/reference/iterableArrayPattern27.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern27.types create mode 100644 tests/baselines/reference/iterableArrayPattern28.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern28.types create mode 100644 tests/baselines/reference/iterableArrayPattern29.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern29.types create mode 100644 tests/baselines/reference/iterableArrayPattern5.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern5.types create mode 100644 tests/baselines/reference/iterableArrayPattern6.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern6.types create mode 100644 tests/baselines/reference/iterableArrayPattern7.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern7.types create mode 100644 tests/baselines/reference/iterableArrayPattern8.symbols create mode 100644 tests/baselines/reference/iterableArrayPattern8.types create mode 100644 tests/baselines/reference/iteratorSpreadInArray10.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInArray10.types create mode 100644 tests/baselines/reference/iteratorSpreadInArray5.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInArray5.types create mode 100644 tests/baselines/reference/iteratorSpreadInArray6.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInArray6.types create mode 100644 tests/baselines/reference/iteratorSpreadInArray8.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInArray8.types create mode 100644 tests/baselines/reference/iteratorSpreadInArray9.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInArray9.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall10.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall10.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall2.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall2.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall4.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall4.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall6.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall6.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall7.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall7.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall8.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall8.types create mode 100644 tests/baselines/reference/iteratorSpreadInCall9.symbols create mode 100644 tests/baselines/reference/iteratorSpreadInCall9.types create mode 100644 tests/baselines/reference/jsFileClassPropertyType.symbols create mode 100644 tests/baselines/reference/jsFileClassPropertyType.types create mode 100644 tests/baselines/reference/jsFileClassPropertyType2.symbols create mode 100644 tests/baselines/reference/jsFileClassPropertyType2.types create mode 100644 tests/baselines/reference/jsFileClassPropertyType3.symbols create mode 100644 tests/baselines/reference/jsFileClassPropertyType3.types create mode 100644 tests/baselines/reference/jsFileCompilationAbstractModifier.symbols create mode 100644 tests/baselines/reference/jsFileCompilationAbstractModifier.types create mode 100644 tests/baselines/reference/jsFileCompilationAmbientVarDeclarationSyntax.symbols create mode 100644 tests/baselines/reference/jsFileCompilationAmbientVarDeclarationSyntax.types create mode 100644 tests/baselines/reference/jsFileCompilationBindDuplicateIdentifier.symbols create mode 100644 tests/baselines/reference/jsFileCompilationBindDuplicateIdentifier.types create mode 100644 tests/baselines/reference/jsFileCompilationBindErrors.symbols create mode 100644 tests/baselines/reference/jsFileCompilationBindErrors.types create mode 100644 tests/baselines/reference/jsFileCompilationBindMultipleDefaultExports.symbols create mode 100644 tests/baselines/reference/jsFileCompilationBindMultipleDefaultExports.types create mode 100644 tests/baselines/reference/jsFileCompilationBindReachabilityErrors.symbols create mode 100644 tests/baselines/reference/jsFileCompilationBindReachabilityErrors.types create mode 100644 tests/baselines/reference/jsFileCompilationBindStrictModeErrors.symbols create mode 100644 tests/baselines/reference/jsFileCompilationBindStrictModeErrors.types create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateFunctionImplementation.symbols create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateFunctionImplementation.types create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateFunctionImplementationFileOrderReversed.symbols create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateFunctionImplementationFileOrderReversed.types create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateVariable.symbols create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateVariable.types create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateVariableErrorReported.symbols create mode 100644 tests/baselines/reference/jsFileCompilationDuplicateVariableErrorReported.types create mode 100644 tests/baselines/reference/jsFileCompilationEmitBlockedCorrectly.symbols create mode 100644 tests/baselines/reference/jsFileCompilationEmitBlockedCorrectly.types create mode 100644 tests/baselines/reference/jsFileCompilationEmitDeclarations.symbols create mode 100644 tests/baselines/reference/jsFileCompilationEmitDeclarations.types create mode 100644 tests/baselines/reference/jsFileCompilationEmitTrippleSlashReference.symbols create mode 100644 tests/baselines/reference/jsFileCompilationEmitTrippleSlashReference.types create mode 100644 tests/baselines/reference/jsFileCompilationEnumSyntax.symbols create mode 100644 tests/baselines/reference/jsFileCompilationEnumSyntax.types create mode 100644 tests/baselines/reference/jsFileCompilationErrorOnDeclarationsWithJsFileReferenceWithNoOut.symbols create mode 100644 tests/baselines/reference/jsFileCompilationErrorOnDeclarationsWithJsFileReferenceWithNoOut.types create mode 100644 tests/baselines/reference/jsFileCompilationErrorOnDeclarationsWithJsFileReferenceWithOut.symbols create mode 100644 tests/baselines/reference/jsFileCompilationErrorOnDeclarationsWithJsFileReferenceWithOut.types create mode 100644 tests/baselines/reference/jsFileCompilationErrorOnDeclarationsWithJsFileReferenceWithOutDir.symbols create mode 100644 tests/baselines/reference/jsFileCompilationErrorOnDeclarationsWithJsFileReferenceWithOutDir.types create mode 100644 tests/baselines/reference/jsFileCompilationExportAssignmentSyntax.symbols create mode 100644 tests/baselines/reference/jsFileCompilationExportAssignmentSyntax.types create mode 100644 tests/baselines/reference/jsFileCompilationHeritageClauseSyntaxOfClass.symbols create mode 100644 tests/baselines/reference/jsFileCompilationHeritageClauseSyntaxOfClass.types create mode 100644 tests/baselines/reference/jsFileCompilationImportEqualsSyntax.symbols create mode 100644 tests/baselines/reference/jsFileCompilationImportEqualsSyntax.types create mode 100644 tests/baselines/reference/jsFileCompilationInterfaceSyntax.symbols create mode 100644 tests/baselines/reference/jsFileCompilationInterfaceSyntax.types create mode 100644 tests/baselines/reference/jsFileCompilationLetDeclarationOrder.symbols create mode 100644 tests/baselines/reference/jsFileCompilationLetDeclarationOrder.types create mode 100644 tests/baselines/reference/jsFileCompilationLetDeclarationOrder2.symbols create mode 100644 tests/baselines/reference/jsFileCompilationLetDeclarationOrder2.types create mode 100644 tests/baselines/reference/jsFileCompilationModuleSyntax.symbols create mode 100644 tests/baselines/reference/jsFileCompilationModuleSyntax.types create mode 100644 tests/baselines/reference/jsFileCompilationNoErrorWithoutDeclarationsWithJsFileReferenceWithNoOut.symbols create mode 100644 tests/baselines/reference/jsFileCompilationNoErrorWithoutDeclarationsWithJsFileReferenceWithNoOut.types create mode 100644 tests/baselines/reference/jsFileCompilationNonNullAssertion.symbols create mode 100644 tests/baselines/reference/jsFileCompilationNonNullAssertion.types create mode 100644 tests/baselines/reference/jsFileCompilationOptionalParameter.symbols create mode 100644 tests/baselines/reference/jsFileCompilationOptionalParameter.types create mode 100644 tests/baselines/reference/jsFileCompilationPublicMethodSyntaxOfClass.symbols create mode 100644 tests/baselines/reference/jsFileCompilationPublicMethodSyntaxOfClass.types create mode 100644 tests/baselines/reference/jsFileCompilationPublicParameterModifier.symbols create mode 100644 tests/baselines/reference/jsFileCompilationPublicParameterModifier.types create mode 100644 tests/baselines/reference/jsFileCompilationReturnTypeSyntaxOfFunction.symbols create mode 100644 tests/baselines/reference/jsFileCompilationReturnTypeSyntaxOfFunction.types create mode 100644 tests/baselines/reference/jsFileCompilationSyntaxError.symbols create mode 100644 tests/baselines/reference/jsFileCompilationSyntaxError.types create mode 100644 tests/baselines/reference/jsFileCompilationTypeAliasSyntax.symbols create mode 100644 tests/baselines/reference/jsFileCompilationTypeAliasSyntax.types create mode 100644 tests/baselines/reference/jsFileCompilationTypeArgumentSyntaxOfCall.symbols create mode 100644 tests/baselines/reference/jsFileCompilationTypeArgumentSyntaxOfCall.types create mode 100644 tests/baselines/reference/jsFileCompilationTypeAssertions.symbols create mode 100644 tests/baselines/reference/jsFileCompilationTypeAssertions.types create mode 100644 tests/baselines/reference/jsFileCompilationTypeOfParameter.symbols create mode 100644 tests/baselines/reference/jsFileCompilationTypeOfParameter.types create mode 100644 tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfClass.symbols create mode 100644 tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfClass.types create mode 100644 tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfFunction.symbols create mode 100644 tests/baselines/reference/jsFileCompilationTypeParameterSyntaxOfFunction.types create mode 100644 tests/baselines/reference/jsFileCompilationTypeSyntaxOfVar.symbols create mode 100644 tests/baselines/reference/jsFileCompilationTypeSyntaxOfVar.types create mode 100644 tests/baselines/reference/jsFileCompilationWithDeclarationEmitPathSameAsInput.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithDeclarationEmitPathSameAsInput.types create mode 100644 tests/baselines/reference/jsFileCompilationWithJsEmitPathSameAsInput.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithJsEmitPathSameAsInput.types create mode 100644 tests/baselines/reference/jsFileCompilationWithMapFileAsJs.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithMapFileAsJs.types create mode 100644 tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithInlineSourceMap.types create mode 100644 tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithMapFileAsJsWithOutDir.types create mode 100644 tests/baselines/reference/jsFileCompilationWithOutDeclarationFileNameSameAsInputJsFile.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithOutDeclarationFileNameSameAsInputJsFile.types create mode 100644 tests/baselines/reference/jsFileCompilationWithOutFileNameSameAsInputJsFile.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithOutFileNameSameAsInputJsFile.types create mode 100644 tests/baselines/reference/jsFileCompilationWithoutOut.symbols create mode 100644 tests/baselines/reference/jsFileCompilationWithoutOut.types create mode 100644 tests/baselines/reference/jsFileFunctionParametersAsOptional2.symbols create mode 100644 tests/baselines/reference/jsFileFunctionParametersAsOptional2.types create mode 100644 tests/baselines/reference/jsPropertyAssignedAfterMethodDeclaration.symbols create mode 100644 tests/baselines/reference/jsPropertyAssignedAfterMethodDeclaration.types create mode 100644 tests/baselines/reference/jsdocDisallowedInTypescript.symbols create mode 100644 tests/baselines/reference/jsdocDisallowedInTypescript.types create mode 100644 tests/baselines/reference/jsdocInTypeScript.symbols create mode 100644 tests/baselines/reference/jsdocInTypeScript.types create mode 100644 tests/baselines/reference/jsdocParameterParsingInfiniteLoop.symbols create mode 100644 tests/baselines/reference/jsdocParameterParsingInfiniteLoop.types create mode 100644 tests/baselines/reference/jsdocParseErrorsInTypescript.symbols create mode 100644 tests/baselines/reference/jsdocParseErrorsInTypescript.types create mode 100644 tests/baselines/reference/jsdocTypeNongenericInstantiationAttempt.symbols create mode 100644 tests/baselines/reference/jsdocTypeNongenericInstantiationAttempt.types create mode 100644 tests/baselines/reference/jsdocTypeTagCast.symbols create mode 100644 tests/baselines/reference/jsdocTypeTagCast.types create mode 100644 tests/baselines/reference/jsdocTypedefNoCrash2.symbols create mode 100644 tests/baselines/reference/jsdocTypedefNoCrash2.types create mode 100644 tests/baselines/reference/jsxAndTypeAssertion.symbols create mode 100644 tests/baselines/reference/jsxAndTypeAssertion.types create mode 100644 tests/baselines/reference/jsxAttributeWithoutExpressionReact.symbols create mode 100644 tests/baselines/reference/jsxAttributeWithoutExpressionReact.types create mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.symbols create mode 100644 tests/baselines/reference/jsxEsprimaFbTestSuite.types create mode 100644 tests/baselines/reference/jsxFactoryAndReactNamespace.symbols create mode 100644 tests/baselines/reference/jsxFactoryAndReactNamespace.types create mode 100644 tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.symbols create mode 100644 tests/baselines/reference/jsxFactoryIdentifierWithAbsentParameter.types create mode 100644 tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.symbols create mode 100644 tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName.types create mode 100644 tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.symbols create mode 100644 tests/baselines/reference/jsxFactoryNotIdentifierOrQualifiedName2.types create mode 100644 tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.symbols create mode 100644 tests/baselines/reference/jsxFactoryQualifiedNameResolutionError.types create mode 100644 tests/baselines/reference/jsxInvalidEsprimaTestSuite.symbols create mode 100644 tests/baselines/reference/jsxInvalidEsprimaTestSuite.types create mode 100644 tests/baselines/reference/jsxParsingError1.symbols create mode 100644 tests/baselines/reference/jsxParsingError1.types create mode 100644 tests/baselines/reference/jsxParsingError2.symbols create mode 100644 tests/baselines/reference/jsxParsingError2.types create mode 100644 tests/baselines/reference/jsxViaImport.symbols create mode 100644 tests/baselines/reference/jsxViaImport.types create mode 100644 tests/baselines/reference/keyofAndIndexedAccessErrors.symbols create mode 100644 tests/baselines/reference/keyofAndIndexedAccessErrors.types create mode 100644 tests/baselines/reference/keyofIsLiteralContexualType.symbols create mode 100644 tests/baselines/reference/keyofIsLiteralContexualType.types create mode 100644 tests/baselines/reference/knockout.symbols create mode 100644 tests/baselines/reference/knockout.types create mode 100644 tests/baselines/reference/lambdaArgCrash.symbols create mode 100644 tests/baselines/reference/lambdaArgCrash.types create mode 100644 tests/baselines/reference/lambdaParamTypes.symbols create mode 100644 tests/baselines/reference/lambdaParamTypes.types create mode 100644 tests/baselines/reference/lambdaPropSelf.symbols create mode 100644 tests/baselines/reference/lambdaPropSelf.types create mode 100644 tests/baselines/reference/largeControlFlowGraph.symbols create mode 100644 tests/baselines/reference/largeControlFlowGraph.types create mode 100644 tests/baselines/reference/lastPropertyInLiteralWins.symbols create mode 100644 tests/baselines/reference/lastPropertyInLiteralWins.types create mode 100644 tests/baselines/reference/letAndVarRedeclaration.symbols create mode 100644 tests/baselines/reference/letAndVarRedeclaration.types create mode 100644 tests/baselines/reference/letAsIdentifier.symbols create mode 100644 tests/baselines/reference/letAsIdentifier.types create mode 100644 tests/baselines/reference/letAsIdentifierInStrictMode.symbols create mode 100644 tests/baselines/reference/letAsIdentifierInStrictMode.types create mode 100644 tests/baselines/reference/letConstInCaseClauses.symbols create mode 100644 tests/baselines/reference/letConstInCaseClauses.types create mode 100644 tests/baselines/reference/letDeclarations-invalidContexts.symbols create mode 100644 tests/baselines/reference/letDeclarations-invalidContexts.types create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates.types create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates2.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates2.types create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates3.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates3.types create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates4.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates4.types create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates5.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates5.types create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates6.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates6.types create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates7.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes-duplicates7.types create mode 100644 tests/baselines/reference/letDeclarations-scopes.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes.types create mode 100644 tests/baselines/reference/letDeclarations-scopes2.symbols create mode 100644 tests/baselines/reference/letDeclarations-scopes2.types create mode 100644 tests/baselines/reference/letDeclarations-useBeforeDefinition.symbols create mode 100644 tests/baselines/reference/letDeclarations-useBeforeDefinition.types create mode 100644 tests/baselines/reference/letDeclarations-useBeforeDefinition2.symbols create mode 100644 tests/baselines/reference/letDeclarations-useBeforeDefinition2.types create mode 100644 tests/baselines/reference/letDeclarations-validContexts.symbols create mode 100644 tests/baselines/reference/letDeclarations-validContexts.types create mode 100644 tests/baselines/reference/letInConstDeclarations_ES5.symbols create mode 100644 tests/baselines/reference/letInConstDeclarations_ES5.types create mode 100644 tests/baselines/reference/letInConstDeclarations_ES6.symbols create mode 100644 tests/baselines/reference/letInConstDeclarations_ES6.types create mode 100644 tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.symbols create mode 100644 tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES5.types create mode 100644 tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.symbols create mode 100644 tests/baselines/reference/letInLetConstDeclOfForOfAndForIn_ES6.types create mode 100644 tests/baselines/reference/letInLetDeclarations_ES5.symbols create mode 100644 tests/baselines/reference/letInLetDeclarations_ES5.types create mode 100644 tests/baselines/reference/letInLetDeclarations_ES6.symbols create mode 100644 tests/baselines/reference/letInLetDeclarations_ES6.types create mode 100644 tests/baselines/reference/letShadowedByNameInNestedScope.symbols create mode 100644 tests/baselines/reference/letShadowedByNameInNestedScope.types create mode 100644 tests/baselines/reference/libMembers.symbols create mode 100644 tests/baselines/reference/libMembers.types create mode 100644 tests/baselines/reference/library-reference-15.symbols create mode 100644 tests/baselines/reference/library-reference-15.types create mode 100644 tests/baselines/reference/library-reference-5.symbols create mode 100644 tests/baselines/reference/library-reference-5.types create mode 100644 tests/baselines/reference/lift.symbols create mode 100644 tests/baselines/reference/lift.types create mode 100644 tests/baselines/reference/limitDeepInstantiations.symbols create mode 100644 tests/baselines/reference/limitDeepInstantiations.types create mode 100644 tests/baselines/reference/literalTypesWidenInParameterPosition.symbols create mode 100644 tests/baselines/reference/literalTypesWidenInParameterPosition.types create mode 100644 tests/baselines/reference/literals-negative.symbols create mode 100644 tests/baselines/reference/literals-negative.types create mode 100644 tests/baselines/reference/literals.symbols create mode 100644 tests/baselines/reference/literals.types create mode 100644 tests/baselines/reference/literalsInComputedProperties1.symbols create mode 100644 tests/baselines/reference/literalsInComputedProperties1.types create mode 100644 tests/baselines/reference/localTypes4.symbols create mode 100644 tests/baselines/reference/localTypes4.types create mode 100644 tests/baselines/reference/logicalNotExpression1.symbols create mode 100644 tests/baselines/reference/logicalNotExpression1.types create mode 100644 tests/baselines/reference/logicalNotOperatorInvalidOperations.symbols create mode 100644 tests/baselines/reference/logicalNotOperatorInvalidOperations.types create mode 100644 tests/baselines/reference/logicalNotOperatorWithAnyOtherType.symbols create mode 100644 tests/baselines/reference/logicalNotOperatorWithAnyOtherType.types create mode 100644 tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.symbols create mode 100644 tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.types create mode 100644 tests/baselines/reference/looseThisTypeInFunctions.symbols create mode 100644 tests/baselines/reference/looseThisTypeInFunctions.types create mode 100644 tests/baselines/reference/mappedTypeErrors.symbols create mode 100644 tests/baselines/reference/mappedTypeErrors.types create mode 100644 tests/baselines/reference/mappedTypeErrors2.symbols create mode 100644 tests/baselines/reference/mappedTypeErrors2.types create mode 100644 tests/baselines/reference/mappedTypeIndexedAccess.symbols create mode 100644 tests/baselines/reference/mappedTypeIndexedAccess.types create mode 100644 tests/baselines/reference/mappedTypeRelationships.symbols create mode 100644 tests/baselines/reference/mappedTypeRelationships.types create mode 100644 tests/baselines/reference/mappedTypeWithCombinedTypeMappers.symbols create mode 100644 tests/baselines/reference/mappedTypeWithCombinedTypeMappers.types create mode 100644 tests/baselines/reference/matchReturnTypeInAllBranches.symbols create mode 100644 tests/baselines/reference/matchReturnTypeInAllBranches.types create mode 100644 tests/baselines/reference/maxConstraints.symbols create mode 100644 tests/baselines/reference/maxConstraints.types create mode 100644 tests/baselines/reference/maxNodeModuleJsDepthDefaultsToZero.symbols create mode 100644 tests/baselines/reference/maxNodeModuleJsDepthDefaultsToZero.types create mode 100644 tests/baselines/reference/maximum10SpellingSuggestions.symbols create mode 100644 tests/baselines/reference/maximum10SpellingSuggestions.types create mode 100644 tests/baselines/reference/memberFunctionOverloadMixingStaticAndInstance.symbols create mode 100644 tests/baselines/reference/memberFunctionOverloadMixingStaticAndInstance.types create mode 100644 tests/baselines/reference/memberFunctionsWithPrivateOverloads.symbols create mode 100644 tests/baselines/reference/memberFunctionsWithPrivateOverloads.types create mode 100644 tests/baselines/reference/memberFunctionsWithPublicPrivateOverloads.symbols create mode 100644 tests/baselines/reference/memberFunctionsWithPublicPrivateOverloads.types create mode 100644 tests/baselines/reference/memberOverride.symbols create mode 100644 tests/baselines/reference/memberOverride.types create mode 100644 tests/baselines/reference/memberScope.symbols create mode 100644 tests/baselines/reference/memberScope.types create mode 100644 tests/baselines/reference/mergedClassWithNamespacePrototype.symbols create mode 100644 tests/baselines/reference/mergedClassWithNamespacePrototype.types create mode 100644 tests/baselines/reference/mergedDeclarationExports.symbols create mode 100644 tests/baselines/reference/mergedDeclarationExports.types create mode 100644 tests/baselines/reference/mergedDeclarations2.symbols create mode 100644 tests/baselines/reference/mergedDeclarations2.types create mode 100644 tests/baselines/reference/mergedDeclarations3.symbols create mode 100644 tests/baselines/reference/mergedDeclarations3.types create mode 100644 tests/baselines/reference/mergedDeclarations7.symbols create mode 100644 tests/baselines/reference/mergedDeclarations7.types create mode 100644 tests/baselines/reference/mergedInterfacesWithConflictingPropertyNames.symbols create mode 100644 tests/baselines/reference/mergedInterfacesWithConflictingPropertyNames.types create mode 100644 tests/baselines/reference/mergedInterfacesWithIndexers2.symbols create mode 100644 tests/baselines/reference/mergedInterfacesWithIndexers2.types create mode 100644 tests/baselines/reference/mergedInterfacesWithInheritedPrivates.symbols create mode 100644 tests/baselines/reference/mergedInterfacesWithInheritedPrivates.types create mode 100644 tests/baselines/reference/mergedInterfacesWithInheritedPrivates2.symbols create mode 100644 tests/baselines/reference/mergedInterfacesWithInheritedPrivates2.types create mode 100644 tests/baselines/reference/mergedInterfacesWithInheritedPrivates3.symbols create mode 100644 tests/baselines/reference/mergedInterfacesWithInheritedPrivates3.types create mode 100644 tests/baselines/reference/mergedInterfacesWithMultipleBases4.symbols create mode 100644 tests/baselines/reference/mergedInterfacesWithMultipleBases4.types create mode 100644 tests/baselines/reference/methodInAmbientClass1.symbols create mode 100644 tests/baselines/reference/methodInAmbientClass1.types create mode 100644 tests/baselines/reference/methodSignaturesWithOverloads.symbols create mode 100644 tests/baselines/reference/methodSignaturesWithOverloads.types create mode 100644 tests/baselines/reference/mismatchedClassConstructorVariable.symbols create mode 100644 tests/baselines/reference/mismatchedClassConstructorVariable.types create mode 100644 tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.symbols create mode 100644 tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.types create mode 100644 tests/baselines/reference/missingAndExcessProperties.symbols create mode 100644 tests/baselines/reference/missingAndExcessProperties.types create mode 100644 tests/baselines/reference/missingArgument1.symbols create mode 100644 tests/baselines/reference/missingArgument1.types create mode 100644 tests/baselines/reference/missingDecoratorType.symbols create mode 100644 tests/baselines/reference/missingDecoratorType.types create mode 100644 tests/baselines/reference/missingFunctionImplementation.symbols create mode 100644 tests/baselines/reference/missingFunctionImplementation.types create mode 100644 tests/baselines/reference/missingFunctionImplementation2.symbols create mode 100644 tests/baselines/reference/missingFunctionImplementation2.types create mode 100644 tests/baselines/reference/missingPropertiesOfClassExpression.symbols create mode 100644 tests/baselines/reference/missingPropertiesOfClassExpression.types create mode 100644 tests/baselines/reference/missingRequiredDeclare.d.symbols create mode 100644 tests/baselines/reference/missingRequiredDeclare.d.types create mode 100644 tests/baselines/reference/missingReturnStatement.symbols create mode 100644 tests/baselines/reference/missingReturnStatement.types create mode 100644 tests/baselines/reference/missingReturnStatement1.symbols create mode 100644 tests/baselines/reference/missingReturnStatement1.types create mode 100644 tests/baselines/reference/missingTypeArguments1.symbols create mode 100644 tests/baselines/reference/missingTypeArguments1.types create mode 100644 tests/baselines/reference/missingTypeArguments2.symbols create mode 100644 tests/baselines/reference/missingTypeArguments2.types create mode 100644 tests/baselines/reference/misspelledNewMetaProperty.symbols create mode 100644 tests/baselines/reference/misspelledNewMetaProperty.types create mode 100644 tests/baselines/reference/mixedStaticAndInstanceClassMembers.symbols create mode 100644 tests/baselines/reference/mixedStaticAndInstanceClassMembers.types create mode 100644 tests/baselines/reference/mixinAccessModifiers.symbols create mode 100644 tests/baselines/reference/mixinAccessModifiers.types create mode 100644 tests/baselines/reference/mixinPrivateAndProtected.symbols create mode 100644 tests/baselines/reference/mixinPrivateAndProtected.types create mode 100644 tests/baselines/reference/mixingStaticAndInstanceOverloads.symbols create mode 100644 tests/baselines/reference/mixingStaticAndInstanceOverloads.types create mode 100644 tests/baselines/reference/modifierOnParameter1.symbols create mode 100644 tests/baselines/reference/modifierOnParameter1.types create mode 100644 tests/baselines/reference/modifiersInObjectLiterals.symbols create mode 100644 tests/baselines/reference/modifiersInObjectLiterals.types create mode 100644 tests/baselines/reference/modifiersOnInterfaceIndexSignature1.symbols create mode 100644 tests/baselines/reference/modifiersOnInterfaceIndexSignature1.types create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6ArrayWithOnlyES6ArrayLib.types create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingES6FeaturesWithOnlyES5Lib.types create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.symbols create mode 100644 tests/baselines/reference/modularizeLibrary_ErrorFromUsingWellknownSymbolWithOutES6WellknownSymbolLib.types create mode 100644 tests/baselines/reference/moduleAndInterfaceSharingName2.symbols create mode 100644 tests/baselines/reference/moduleAndInterfaceSharingName2.types create mode 100644 tests/baselines/reference/moduleAndInterfaceWithSameName.symbols create mode 100644 tests/baselines/reference/moduleAndInterfaceWithSameName.types create mode 100644 tests/baselines/reference/moduleAsBaseType.symbols create mode 100644 tests/baselines/reference/moduleAsBaseType.types create mode 100644 tests/baselines/reference/moduleAssignmentCompat1.symbols create mode 100644 tests/baselines/reference/moduleAssignmentCompat1.types create mode 100644 tests/baselines/reference/moduleAssignmentCompat2.symbols create mode 100644 tests/baselines/reference/moduleAssignmentCompat2.types create mode 100644 tests/baselines/reference/moduleAssignmentCompat3.symbols create mode 100644 tests/baselines/reference/moduleAssignmentCompat3.types create mode 100644 tests/baselines/reference/moduleAssignmentCompat4.symbols create mode 100644 tests/baselines/reference/moduleAssignmentCompat4.types create mode 100644 tests/baselines/reference/moduleAugmentationDisallowedExtensions.symbols create mode 100644 tests/baselines/reference/moduleAugmentationDisallowedExtensions.types create mode 100644 tests/baselines/reference/moduleAugmentationGlobal6.symbols create mode 100644 tests/baselines/reference/moduleAugmentationGlobal6.types create mode 100644 tests/baselines/reference/moduleAugmentationGlobal6_1.symbols create mode 100644 tests/baselines/reference/moduleAugmentationGlobal6_1.types create mode 100644 tests/baselines/reference/moduleAugmentationGlobal7.symbols create mode 100644 tests/baselines/reference/moduleAugmentationGlobal7.types create mode 100644 tests/baselines/reference/moduleAugmentationGlobal7_1.symbols create mode 100644 tests/baselines/reference/moduleAugmentationGlobal7_1.types create mode 100644 tests/baselines/reference/moduleAugmentationGlobal8.symbols create mode 100644 tests/baselines/reference/moduleAugmentationGlobal8.types create mode 100644 tests/baselines/reference/moduleAugmentationGlobal8_1.symbols create mode 100644 tests/baselines/reference/moduleAugmentationGlobal8_1.types create mode 100644 tests/baselines/reference/moduleAugmentationImportsAndExports2.symbols create mode 100644 tests/baselines/reference/moduleAugmentationImportsAndExports2.types create mode 100644 tests/baselines/reference/moduleAugmentationImportsAndExports3.symbols create mode 100644 tests/baselines/reference/moduleAugmentationImportsAndExports3.types create mode 100644 tests/baselines/reference/moduleAugmentationImportsAndExports5.symbols create mode 100644 tests/baselines/reference/moduleAugmentationImportsAndExports5.types create mode 100644 tests/baselines/reference/moduleAugmentationInDependency2.symbols create mode 100644 tests/baselines/reference/moduleAugmentationInDependency2.types create mode 100644 tests/baselines/reference/moduleClassArrayCodeGenTest.symbols create mode 100644 tests/baselines/reference/moduleClassArrayCodeGenTest.types create mode 100644 tests/baselines/reference/moduleCrashBug1.symbols create mode 100644 tests/baselines/reference/moduleCrashBug1.types create mode 100644 tests/baselines/reference/moduleDuplicateIdentifiers.symbols create mode 100644 tests/baselines/reference/moduleDuplicateIdentifiers.types create mode 100644 tests/baselines/reference/moduleElementsInWrongContext.symbols create mode 100644 tests/baselines/reference/moduleElementsInWrongContext.types create mode 100644 tests/baselines/reference/moduleElementsInWrongContext2.symbols create mode 100644 tests/baselines/reference/moduleElementsInWrongContext2.types create mode 100644 tests/baselines/reference/moduleElementsInWrongContext3.symbols create mode 100644 tests/baselines/reference/moduleElementsInWrongContext3.types create mode 100644 tests/baselines/reference/moduleExports1.symbols create mode 100644 tests/baselines/reference/moduleExports1.types create mode 100644 tests/baselines/reference/moduleImport.symbols create mode 100644 tests/baselines/reference/moduleImport.types create mode 100644 tests/baselines/reference/moduleInTypePosition1.symbols create mode 100644 tests/baselines/reference/moduleInTypePosition1.types create mode 100644 tests/baselines/reference/moduleKeywordRepeatError.symbols create mode 100644 tests/baselines/reference/moduleKeywordRepeatError.types create mode 100644 tests/baselines/reference/moduleNewExportBug.symbols create mode 100644 tests/baselines/reference/moduleNewExportBug.types create mode 100644 tests/baselines/reference/moduleNoneErrors.symbols create mode 100644 tests/baselines/reference/moduleNoneErrors.types create mode 100644 tests/baselines/reference/moduleProperty1.symbols create mode 100644 tests/baselines/reference/moduleProperty1.types create mode 100644 tests/baselines/reference/moduleProperty2.symbols create mode 100644 tests/baselines/reference/moduleProperty2.types create mode 100644 tests/baselines/reference/moduleResolutionNoTs.symbols create mode 100644 tests/baselines/reference/moduleResolutionNoTs.types create mode 100644 tests/baselines/reference/moduleResolutionWithExtensions_notSupported.symbols create mode 100644 tests/baselines/reference/moduleResolutionWithExtensions_notSupported.types create mode 100644 tests/baselines/reference/moduleResolutionWithExtensions_notSupported2.symbols create mode 100644 tests/baselines/reference/moduleResolutionWithExtensions_notSupported2.types create mode 100644 tests/baselines/reference/moduleResolutionWithSymlinks_preserveSymlinks.symbols create mode 100644 tests/baselines/reference/moduleResolutionWithSymlinks_preserveSymlinks.types create mode 100644 tests/baselines/reference/moduleResolution_relativeImportJsFile_noImplicitAny.symbols create mode 100644 tests/baselines/reference/moduleResolution_relativeImportJsFile_noImplicitAny.types create mode 100644 tests/baselines/reference/moduleSharesNameWithImportDeclarationInsideIt3.symbols create mode 100644 tests/baselines/reference/moduleSharesNameWithImportDeclarationInsideIt3.types create mode 100644 tests/baselines/reference/moduleSharesNameWithImportDeclarationInsideIt5.symbols create mode 100644 tests/baselines/reference/moduleSharesNameWithImportDeclarationInsideIt5.types create mode 100644 tests/baselines/reference/moduleVisibilityTest2.symbols create mode 100644 tests/baselines/reference/moduleVisibilityTest2.types create mode 100644 tests/baselines/reference/moduleVisibilityTest3.symbols create mode 100644 tests/baselines/reference/moduleVisibilityTest3.types create mode 100644 tests/baselines/reference/moduleWithNoValuesAsType.symbols create mode 100644 tests/baselines/reference/moduleWithNoValuesAsType.types create mode 100644 tests/baselines/reference/moduleWithValuesAsType.symbols create mode 100644 tests/baselines/reference/moduleWithValuesAsType.types create mode 100644 tests/baselines/reference/module_augmentExistingAmbientVariable.symbols create mode 100644 tests/baselines/reference/module_augmentExistingAmbientVariable.types create mode 100644 tests/baselines/reference/module_augmentExistingVariable.symbols create mode 100644 tests/baselines/reference/module_augmentExistingVariable.types create mode 100644 tests/baselines/reference/multiExtendsSplitInterfaces1.symbols create mode 100644 tests/baselines/reference/multiExtendsSplitInterfaces1.types create mode 100644 tests/baselines/reference/multiLineErrors.symbols create mode 100644 tests/baselines/reference/multiLineErrors.types create mode 100644 tests/baselines/reference/multiLinePropertyAccessAndArrowFunctionIndent1.symbols create mode 100644 tests/baselines/reference/multiLinePropertyAccessAndArrowFunctionIndent1.types create mode 100644 tests/baselines/reference/multipleBaseInterfaesWithIncompatibleProperties.symbols create mode 100644 tests/baselines/reference/multipleBaseInterfaesWithIncompatibleProperties.types create mode 100644 tests/baselines/reference/multipleClassPropertyModifiers.symbols create mode 100644 tests/baselines/reference/multipleClassPropertyModifiers.types create mode 100644 tests/baselines/reference/multipleClassPropertyModifiersErrors.symbols create mode 100644 tests/baselines/reference/multipleClassPropertyModifiersErrors.types create mode 100644 tests/baselines/reference/multipleDefaultExports01.symbols create mode 100644 tests/baselines/reference/multipleDefaultExports01.types create mode 100644 tests/baselines/reference/multipleDefaultExports02.symbols create mode 100644 tests/baselines/reference/multipleDefaultExports02.types create mode 100644 tests/baselines/reference/multipleDefaultExports03.symbols create mode 100644 tests/baselines/reference/multipleDefaultExports03.types create mode 100644 tests/baselines/reference/multipleDefaultExports04.symbols create mode 100644 tests/baselines/reference/multipleDefaultExports04.types create mode 100644 tests/baselines/reference/multipleExportAssignments.symbols create mode 100644 tests/baselines/reference/multipleExportAssignments.types create mode 100644 tests/baselines/reference/multipleExportAssignmentsInAmbientDeclaration.symbols create mode 100644 tests/baselines/reference/multipleExportAssignmentsInAmbientDeclaration.types create mode 100644 tests/baselines/reference/multipleExportDefault1.symbols create mode 100644 tests/baselines/reference/multipleExportDefault1.types create mode 100644 tests/baselines/reference/multipleExportDefault2.symbols create mode 100644 tests/baselines/reference/multipleExportDefault2.types create mode 100644 tests/baselines/reference/multipleExportDefault3.symbols create mode 100644 tests/baselines/reference/multipleExportDefault3.types create mode 100644 tests/baselines/reference/multipleExportDefault4.symbols create mode 100644 tests/baselines/reference/multipleExportDefault4.types create mode 100644 tests/baselines/reference/multipleExportDefault5.symbols create mode 100644 tests/baselines/reference/multipleExportDefault5.types create mode 100644 tests/baselines/reference/multipleExportDefault6.symbols create mode 100644 tests/baselines/reference/multipleExportDefault6.types create mode 100644 tests/baselines/reference/multipleExports.symbols create mode 100644 tests/baselines/reference/multipleExports.types create mode 100644 tests/baselines/reference/multipleInheritance.symbols create mode 100644 tests/baselines/reference/multipleInheritance.types create mode 100644 tests/baselines/reference/multipleNumericIndexers.symbols create mode 100644 tests/baselines/reference/multipleNumericIndexers.types create mode 100644 tests/baselines/reference/multipleStringIndexers.symbols create mode 100644 tests/baselines/reference/multipleStringIndexers.types create mode 100644 tests/baselines/reference/multivar.symbols create mode 100644 tests/baselines/reference/multivar.types create mode 100644 tests/baselines/reference/nameCollisions.symbols create mode 100644 tests/baselines/reference/nameCollisions.types create mode 100644 tests/baselines/reference/namedFunctionExpressionCallErrors.symbols create mode 100644 tests/baselines/reference/namedFunctionExpressionCallErrors.types create mode 100644 tests/baselines/reference/namespacesDeclaration2.symbols create mode 100644 tests/baselines/reference/namespacesDeclaration2.types create mode 100644 tests/baselines/reference/narrowExceptionVariableInCatchClause.symbols create mode 100644 tests/baselines/reference/narrowExceptionVariableInCatchClause.types create mode 100644 tests/baselines/reference/narrowFromAnyWithInstanceof.symbols create mode 100644 tests/baselines/reference/narrowFromAnyWithInstanceof.types create mode 100644 tests/baselines/reference/narrowFromAnyWithTypePredicate.symbols create mode 100644 tests/baselines/reference/narrowFromAnyWithTypePredicate.types create mode 100644 tests/baselines/reference/nativeToBoxedTypes.symbols create mode 100644 tests/baselines/reference/nativeToBoxedTypes.types create mode 100644 tests/baselines/reference/negateOperatorInvalidOperations.symbols create mode 100644 tests/baselines/reference/negateOperatorInvalidOperations.types create mode 100644 tests/baselines/reference/nestedBlockScopedBindings13.symbols create mode 100644 tests/baselines/reference/nestedBlockScopedBindings13.types create mode 100644 tests/baselines/reference/nestedBlockScopedBindings14.symbols create mode 100644 tests/baselines/reference/nestedBlockScopedBindings14.types create mode 100644 tests/baselines/reference/nestedBlockScopedBindings15.symbols create mode 100644 tests/baselines/reference/nestedBlockScopedBindings15.types create mode 100644 tests/baselines/reference/nestedBlockScopedBindings16.symbols create mode 100644 tests/baselines/reference/nestedBlockScopedBindings16.types create mode 100644 tests/baselines/reference/nestedBlockScopedBindings5.symbols create mode 100644 tests/baselines/reference/nestedBlockScopedBindings5.types create mode 100644 tests/baselines/reference/nestedBlockScopedBindings7.symbols create mode 100644 tests/baselines/reference/nestedBlockScopedBindings7.types create mode 100644 tests/baselines/reference/nestedBlockScopedBindings8.symbols create mode 100644 tests/baselines/reference/nestedBlockScopedBindings8.types create mode 100644 tests/baselines/reference/nestedClassDeclaration.symbols create mode 100644 tests/baselines/reference/nestedClassDeclaration.types create mode 100644 tests/baselines/reference/nestedFreshLiteral.symbols create mode 100644 tests/baselines/reference/nestedFreshLiteral.types create mode 100644 tests/baselines/reference/neverTypeErrors1.symbols create mode 100644 tests/baselines/reference/neverTypeErrors1.types create mode 100644 tests/baselines/reference/neverTypeErrors2.symbols create mode 100644 tests/baselines/reference/neverTypeErrors2.types create mode 100644 tests/baselines/reference/newAbstractInstance.symbols create mode 100644 tests/baselines/reference/newAbstractInstance.types create mode 100644 tests/baselines/reference/newExpressionWithCast.symbols create mode 100644 tests/baselines/reference/newExpressionWithCast.types create mode 100644 tests/baselines/reference/newFunctionImplicitAny.symbols create mode 100644 tests/baselines/reference/newFunctionImplicitAny.types create mode 100644 tests/baselines/reference/newMissingIdentifier.symbols create mode 100644 tests/baselines/reference/newMissingIdentifier.types create mode 100644 tests/baselines/reference/newNamesInGlobalAugmentations1.symbols create mode 100644 tests/baselines/reference/newNamesInGlobalAugmentations1.types create mode 100644 tests/baselines/reference/newNonReferenceType.symbols create mode 100644 tests/baselines/reference/newNonReferenceType.types create mode 100644 tests/baselines/reference/newOnInstanceSymbol.symbols create mode 100644 tests/baselines/reference/newOnInstanceSymbol.types create mode 100644 tests/baselines/reference/newOperator.symbols create mode 100644 tests/baselines/reference/newOperator.types create mode 100644 tests/baselines/reference/newOperatorErrorCases.symbols create mode 100644 tests/baselines/reference/newOperatorErrorCases.types create mode 100644 tests/baselines/reference/newWithSpread.symbols create mode 100644 tests/baselines/reference/newWithSpread.types create mode 100644 tests/baselines/reference/noCollisionThisExpressionAndLocalVarInAccessors.symbols create mode 100644 tests/baselines/reference/noCollisionThisExpressionAndLocalVarInAccessors.types create mode 100644 tests/baselines/reference/noCrashOnImportShadowing.symbols create mode 100644 tests/baselines/reference/noCrashOnImportShadowing.types create mode 100644 tests/baselines/reference/noDefaultLib.symbols create mode 100644 tests/baselines/reference/noDefaultLib.types create mode 100644 tests/baselines/reference/noEmitOnError.symbols create mode 100644 tests/baselines/reference/noEmitOnError.types create mode 100644 tests/baselines/reference/noErrorTruncation.symbols create mode 100644 tests/baselines/reference/noErrorTruncation.types create mode 100644 tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.symbols create mode 100644 tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile2.types create mode 100644 tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.symbols create mode 100644 tests/baselines/reference/noErrorUsingImportExportModuleAugmentationInDeclarationFile3.types create mode 100644 tests/baselines/reference/noErrorsInCallback.symbols create mode 100644 tests/baselines/reference/noErrorsInCallback.types create mode 100644 tests/baselines/reference/noImplicitAnyDestructuringParameterDeclaration.symbols create mode 100644 tests/baselines/reference/noImplicitAnyDestructuringParameterDeclaration.types create mode 100644 tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.symbols create mode 100644 tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.types create mode 100644 tests/baselines/reference/noImplicitAnyForIn.symbols create mode 100644 tests/baselines/reference/noImplicitAnyForIn.types create mode 100644 tests/baselines/reference/noImplicitAnyForMethodParameters.symbols create mode 100644 tests/baselines/reference/noImplicitAnyForMethodParameters.types create mode 100644 tests/baselines/reference/noImplicitAnyForwardReferencedInterface.symbols create mode 100644 tests/baselines/reference/noImplicitAnyForwardReferencedInterface.types create mode 100644 tests/baselines/reference/noImplicitAnyFunctions.symbols create mode 100644 tests/baselines/reference/noImplicitAnyFunctions.types create mode 100644 tests/baselines/reference/noImplicitAnyInBareInterface.symbols create mode 100644 tests/baselines/reference/noImplicitAnyInBareInterface.types create mode 100644 tests/baselines/reference/noImplicitAnyInCastExpression.symbols create mode 100644 tests/baselines/reference/noImplicitAnyInCastExpression.types create mode 100644 tests/baselines/reference/noImplicitAnyIndexing.symbols create mode 100644 tests/baselines/reference/noImplicitAnyIndexing.types create mode 100644 tests/baselines/reference/noImplicitAnyMissingGetAccessor.symbols create mode 100644 tests/baselines/reference/noImplicitAnyMissingGetAccessor.types create mode 100644 tests/baselines/reference/noImplicitAnyMissingSetAccessor.symbols create mode 100644 tests/baselines/reference/noImplicitAnyMissingSetAccessor.types create mode 100644 tests/baselines/reference/noImplicitAnyModule.symbols create mode 100644 tests/baselines/reference/noImplicitAnyModule.types create mode 100644 tests/baselines/reference/noImplicitAnyParametersInAmbientClass.symbols create mode 100644 tests/baselines/reference/noImplicitAnyParametersInAmbientClass.types create mode 100644 tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.symbols create mode 100644 tests/baselines/reference/noImplicitAnyParametersInAmbientFunctions.types create mode 100644 tests/baselines/reference/noImplicitAnyParametersInAmbientModule.symbols create mode 100644 tests/baselines/reference/noImplicitAnyParametersInAmbientModule.types create mode 100644 tests/baselines/reference/noImplicitAnyParametersInBareFunctions.symbols create mode 100644 tests/baselines/reference/noImplicitAnyParametersInBareFunctions.types create mode 100644 tests/baselines/reference/noImplicitAnyParametersInClass.symbols create mode 100644 tests/baselines/reference/noImplicitAnyParametersInClass.types create mode 100644 tests/baselines/reference/noImplicitAnyParametersInInterface.symbols create mode 100644 tests/baselines/reference/noImplicitAnyParametersInInterface.types create mode 100644 tests/baselines/reference/noImplicitAnyParametersInModule.symbols create mode 100644 tests/baselines/reference/noImplicitAnyParametersInModule.types create mode 100644 tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.symbols create mode 100644 tests/baselines/reference/noImplicitAnyReferencingDeclaredInterface.types create mode 100644 tests/baselines/reference/noImplicitAnyStringIndexerOnObject.symbols create mode 100644 tests/baselines/reference/noImplicitAnyStringIndexerOnObject.types create mode 100644 tests/baselines/reference/noImplicitAnyWithOverloads.symbols create mode 100644 tests/baselines/reference/noImplicitAnyWithOverloads.types create mode 100644 tests/baselines/reference/noImplicitReturnsInAsync2.symbols create mode 100644 tests/baselines/reference/noImplicitReturnsInAsync2.types create mode 100644 tests/baselines/reference/noImplicitReturnsWithProtectedBlocks2.symbols create mode 100644 tests/baselines/reference/noImplicitReturnsWithProtectedBlocks2.types create mode 100644 tests/baselines/reference/noImplicitReturnsWithProtectedBlocks3.symbols create mode 100644 tests/baselines/reference/noImplicitReturnsWithProtectedBlocks3.types create mode 100644 tests/baselines/reference/noImplicitReturnsWithoutReturnExpression.symbols create mode 100644 tests/baselines/reference/noImplicitReturnsWithoutReturnExpression.types create mode 100644 tests/baselines/reference/noImplicitThisFunctions.symbols create mode 100644 tests/baselines/reference/noImplicitThisFunctions.types create mode 100644 tests/baselines/reference/noSymbolForMergeCrash.symbols create mode 100644 tests/baselines/reference/noSymbolForMergeCrash.types create mode 100644 tests/baselines/reference/noTypeArgumentOnReturnType1.symbols create mode 100644 tests/baselines/reference/noTypeArgumentOnReturnType1.types create mode 100644 tests/baselines/reference/noUnusedLocals_selfReference.symbols create mode 100644 tests/baselines/reference/noUnusedLocals_selfReference.types create mode 100644 tests/baselines/reference/noUnusedLocals_writeOnly.symbols create mode 100644 tests/baselines/reference/noUnusedLocals_writeOnly.types create mode 100644 tests/baselines/reference/noUnusedLocals_writeOnlyProperty.symbols create mode 100644 tests/baselines/reference/noUnusedLocals_writeOnlyProperty.types create mode 100644 tests/baselines/reference/nonArrayRestArgs.symbols create mode 100644 tests/baselines/reference/nonArrayRestArgs.types create mode 100644 tests/baselines/reference/nonExportedElementsOfMergedModules.symbols create mode 100644 tests/baselines/reference/nonExportedElementsOfMergedModules.types create mode 100644 tests/baselines/reference/nonGenericTypeReferenceWithTypeArguments.symbols create mode 100644 tests/baselines/reference/nonGenericTypeReferenceWithTypeArguments.types create mode 100644 tests/baselines/reference/nonIdenticalTypeConstraints.symbols create mode 100644 tests/baselines/reference/nonIdenticalTypeConstraints.types create mode 100644 tests/baselines/reference/nonIterableRestElement3.symbols create mode 100644 tests/baselines/reference/nonIterableRestElement3.types create mode 100644 tests/baselines/reference/nonMergedDeclarationsAndOverloads.symbols create mode 100644 tests/baselines/reference/nonMergedDeclarationsAndOverloads.types create mode 100644 tests/baselines/reference/nonMergedOverloads.symbols create mode 100644 tests/baselines/reference/nonMergedOverloads.types create mode 100644 tests/baselines/reference/nonPrimitiveAccessProperty.symbols create mode 100644 tests/baselines/reference/nonPrimitiveAccessProperty.types create mode 100644 tests/baselines/reference/nonPrimitiveAsProperty.symbols create mode 100644 tests/baselines/reference/nonPrimitiveAsProperty.types create mode 100644 tests/baselines/reference/nonPrimitiveAssignError.symbols create mode 100644 tests/baselines/reference/nonPrimitiveAssignError.types create mode 100644 tests/baselines/reference/nonPrimitiveInFunction.symbols create mode 100644 tests/baselines/reference/nonPrimitiveInFunction.types create mode 100644 tests/baselines/reference/nonPrimitiveInGeneric.symbols create mode 100644 tests/baselines/reference/nonPrimitiveInGeneric.types create mode 100644 tests/baselines/reference/nonPrimitiveIndexingWithForInNoImplicitAny.symbols create mode 100644 tests/baselines/reference/nonPrimitiveIndexingWithForInNoImplicitAny.types create mode 100644 tests/baselines/reference/nonPrimitiveNarrow.symbols create mode 100644 tests/baselines/reference/nonPrimitiveNarrow.types create mode 100644 tests/baselines/reference/nonPrimitiveStrictNull.symbols create mode 100644 tests/baselines/reference/nonPrimitiveStrictNull.types create mode 100644 tests/baselines/reference/nonPrimitiveUnionIntersection.symbols create mode 100644 tests/baselines/reference/nonPrimitiveUnionIntersection.types create mode 100644 tests/baselines/reference/nullAssignedToUndefined.symbols create mode 100644 tests/baselines/reference/nullAssignedToUndefined.types create mode 100644 tests/baselines/reference/nullKeyword.symbols create mode 100644 tests/baselines/reference/nullKeyword.types create mode 100644 tests/baselines/reference/numberToString.symbols create mode 100644 tests/baselines/reference/numberToString.types create mode 100644 tests/baselines/reference/numericClassMembers1.symbols create mode 100644 tests/baselines/reference/numericClassMembers1.types create mode 100644 tests/baselines/reference/numericIndexExpressions.symbols create mode 100644 tests/baselines/reference/numericIndexExpressions.types create mode 100644 tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.symbols create mode 100644 tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.types create mode 100644 tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.symbols create mode 100644 tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.types create mode 100644 tests/baselines/reference/numericIndexerConstraint.symbols create mode 100644 tests/baselines/reference/numericIndexerConstraint.types create mode 100644 tests/baselines/reference/numericIndexerConstraint1.symbols create mode 100644 tests/baselines/reference/numericIndexerConstraint1.types create mode 100644 tests/baselines/reference/numericIndexerConstraint2.symbols create mode 100644 tests/baselines/reference/numericIndexerConstraint2.types create mode 100644 tests/baselines/reference/numericIndexerConstraint5.symbols create mode 100644 tests/baselines/reference/numericIndexerConstraint5.types create mode 100644 tests/baselines/reference/numericIndexerTyping1.symbols create mode 100644 tests/baselines/reference/numericIndexerTyping1.types create mode 100644 tests/baselines/reference/numericIndexerTyping2.symbols create mode 100644 tests/baselines/reference/numericIndexerTyping2.types create mode 100644 tests/baselines/reference/numericLiteralTypes3.symbols create mode 100644 tests/baselines/reference/numericLiteralTypes3.types create mode 100644 tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.symbols create mode 100644 tests/baselines/reference/numericLiteralsWithTrailingDecimalPoints01.types create mode 100644 tests/baselines/reference/numericNamedPropertyDuplicates.symbols create mode 100644 tests/baselines/reference/numericNamedPropertyDuplicates.types create mode 100644 tests/baselines/reference/numericStringNamedPropertyEquivalence.symbols create mode 100644 tests/baselines/reference/numericStringNamedPropertyEquivalence.types create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.symbols create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers01.types create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.symbols create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers02.types create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.symbols create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers03.types create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.symbols create mode 100644 tests/baselines/reference/objectBindingPatternKeywordIdentifiers04.types create mode 100644 tests/baselines/reference/objectCreate-errors.symbols create mode 100644 tests/baselines/reference/objectCreate-errors.types create mode 100644 tests/baselines/reference/objectCreationExpressionInFunctionParameter.symbols create mode 100644 tests/baselines/reference/objectCreationExpressionInFunctionParameter.types create mode 100644 tests/baselines/reference/objectCreationOfElementAccessExpression.symbols create mode 100644 tests/baselines/reference/objectCreationOfElementAccessExpression.types create mode 100644 tests/baselines/reference/objectFreeze.symbols create mode 100644 tests/baselines/reference/objectFreeze.types create mode 100644 tests/baselines/reference/objectLitArrayDeclNoNew.symbols create mode 100644 tests/baselines/reference/objectLitArrayDeclNoNew.types create mode 100644 tests/baselines/reference/objectLitIndexerContextualType.symbols create mode 100644 tests/baselines/reference/objectLitIndexerContextualType.types create mode 100644 tests/baselines/reference/objectLitPropertyScoping.symbols create mode 100644 tests/baselines/reference/objectLitPropertyScoping.types create mode 100644 tests/baselines/reference/objectLitStructuralTypeMismatch.symbols create mode 100644 tests/baselines/reference/objectLitStructuralTypeMismatch.types create mode 100644 tests/baselines/reference/objectLitTargetTypeCallSite.symbols create mode 100644 tests/baselines/reference/objectLitTargetTypeCallSite.types create mode 100644 tests/baselines/reference/objectLiteralErrors.symbols create mode 100644 tests/baselines/reference/objectLiteralErrors.types create mode 100644 tests/baselines/reference/objectLiteralErrorsES3.symbols create mode 100644 tests/baselines/reference/objectLiteralErrorsES3.types create mode 100644 tests/baselines/reference/objectLiteralExcessProperties.symbols create mode 100644 tests/baselines/reference/objectLiteralExcessProperties.types create mode 100644 tests/baselines/reference/objectLiteralFreshnessWithSpread.symbols create mode 100644 tests/baselines/reference/objectLiteralFreshnessWithSpread.types create mode 100644 tests/baselines/reference/objectLiteralFunctionArgContextualTyping.symbols create mode 100644 tests/baselines/reference/objectLiteralFunctionArgContextualTyping.types create mode 100644 tests/baselines/reference/objectLiteralFunctionArgContextualTyping2.symbols create mode 100644 tests/baselines/reference/objectLiteralFunctionArgContextualTyping2.types create mode 100644 tests/baselines/reference/objectLiteralGettersAndSetters.symbols create mode 100644 tests/baselines/reference/objectLiteralGettersAndSetters.types create mode 100644 tests/baselines/reference/objectLiteralIndexerErrors.symbols create mode 100644 tests/baselines/reference/objectLiteralIndexerErrors.types create mode 100644 tests/baselines/reference/objectLiteralMemberWithModifiers1.symbols create mode 100644 tests/baselines/reference/objectLiteralMemberWithModifiers1.types create mode 100644 tests/baselines/reference/objectLiteralMemberWithModifiers2.symbols create mode 100644 tests/baselines/reference/objectLiteralMemberWithModifiers2.types create mode 100644 tests/baselines/reference/objectLiteralMemberWithQuestionMark1.symbols create mode 100644 tests/baselines/reference/objectLiteralMemberWithQuestionMark1.types create mode 100644 tests/baselines/reference/objectLiteralMemberWithoutBlock1.symbols create mode 100644 tests/baselines/reference/objectLiteralMemberWithoutBlock1.types create mode 100644 tests/baselines/reference/objectLiteralParameterResolution.symbols create mode 100644 tests/baselines/reference/objectLiteralParameterResolution.types create mode 100644 tests/baselines/reference/objectLiteralReferencingInternalProperties.symbols create mode 100644 tests/baselines/reference/objectLiteralReferencingInternalProperties.types create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentError.symbols create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentError.types create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.symbols create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesAssignmentErrorFromMissingIdentifier.types create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesErrorFromNoneExistingIdentifier.symbols create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesErrorFromNoneExistingIdentifier.types create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesErrorFromNotUsingIdentifier.symbols create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesErrorFromNotUsingIdentifier.types create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesErrorWithModule.symbols create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesErrorWithModule.types create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument2.symbols create mode 100644 tests/baselines/reference/objectLiteralShorthandPropertiesFunctionArgument2.types create mode 100644 tests/baselines/reference/objectLiteralWithGetAccessorInsideFunction.symbols create mode 100644 tests/baselines/reference/objectLiteralWithGetAccessorInsideFunction.types create mode 100644 tests/baselines/reference/objectLiteralWithNumericPropertyName.symbols create mode 100644 tests/baselines/reference/objectLiteralWithNumericPropertyName.types create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons1.symbols create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons1.types create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons2.symbols create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons2.types create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons3.symbols create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons3.types create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons4.symbols create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons4.types create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons5.symbols create mode 100644 tests/baselines/reference/objectLiteralWithSemicolons5.types create mode 100644 tests/baselines/reference/objectRestNegative.symbols create mode 100644 tests/baselines/reference/objectRestNegative.types create mode 100644 tests/baselines/reference/objectSpreadNegative.symbols create mode 100644 tests/baselines/reference/objectSpreadNegative.types create mode 100644 tests/baselines/reference/objectSpreadNegativeParse.symbols create mode 100644 tests/baselines/reference/objectSpreadNegativeParse.types create mode 100644 tests/baselines/reference/objectSpreadStrictNull.symbols create mode 100644 tests/baselines/reference/objectSpreadStrictNull.types create mode 100644 tests/baselines/reference/objectTypeHidingMembersOfExtendedObject.symbols create mode 100644 tests/baselines/reference/objectTypeHidingMembersOfExtendedObject.types create mode 100644 tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat.symbols create mode 100644 tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat.types create mode 100644 tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat2.symbols create mode 100644 tests/baselines/reference/objectTypeHidingMembersOfObjectAssignmentCompat2.types create mode 100644 tests/baselines/reference/objectTypeLiteralSyntax2.symbols create mode 100644 tests/baselines/reference/objectTypeLiteralSyntax2.types create mode 100644 tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunctionAssignmentCompat.symbols create mode 100644 tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunctionAssignmentCompat.types create mode 100644 tests/baselines/reference/objectTypeWithConstructSignatureAppearsToBeFunctionType.symbols create mode 100644 tests/baselines/reference/objectTypeWithConstructSignatureAppearsToBeFunctionType.types create mode 100644 tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunctionAssignmentCompat.symbols create mode 100644 tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunctionAssignmentCompat.types create mode 100644 tests/baselines/reference/objectTypeWithDuplicateNumericProperty.symbols create mode 100644 tests/baselines/reference/objectTypeWithDuplicateNumericProperty.types create mode 100644 tests/baselines/reference/objectTypeWithOptionalProperty1.symbols create mode 100644 tests/baselines/reference/objectTypeWithOptionalProperty1.types create mode 100644 tests/baselines/reference/objectTypeWithRecursiveWrappedProperty.symbols create mode 100644 tests/baselines/reference/objectTypeWithRecursiveWrappedProperty.types create mode 100644 tests/baselines/reference/objectTypeWithRecursiveWrappedProperty2.symbols create mode 100644 tests/baselines/reference/objectTypeWithRecursiveWrappedProperty2.types create mode 100644 tests/baselines/reference/objectTypeWithRecursiveWrappedPropertyCheckedNominally.symbols create mode 100644 tests/baselines/reference/objectTypeWithRecursiveWrappedPropertyCheckedNominally.types create mode 100644 tests/baselines/reference/objectTypeWithStringIndexerHidingObjectIndexer.symbols create mode 100644 tests/baselines/reference/objectTypeWithStringIndexerHidingObjectIndexer.types create mode 100644 tests/baselines/reference/objectTypesIdentityWithCallSignatures3.symbols create mode 100644 tests/baselines/reference/objectTypesIdentityWithCallSignatures3.types create mode 100644 tests/baselines/reference/objectTypesIdentityWithPrivates3.symbols create mode 100644 tests/baselines/reference/objectTypesIdentityWithPrivates3.types create mode 100644 tests/baselines/reference/objectTypesWithOptionalProperties.symbols create mode 100644 tests/baselines/reference/objectTypesWithOptionalProperties.types create mode 100644 tests/baselines/reference/objectTypesWithOptionalProperties2.symbols create mode 100644 tests/baselines/reference/objectTypesWithOptionalProperties2.types create mode 100644 tests/baselines/reference/objectTypesWithPredefinedTypesAsName.symbols create mode 100644 tests/baselines/reference/objectTypesWithPredefinedTypesAsName.types create mode 100644 tests/baselines/reference/objectTypesWithPredefinedTypesAsName2.symbols create mode 100644 tests/baselines/reference/objectTypesWithPredefinedTypesAsName2.types create mode 100644 tests/baselines/reference/octalIntegerLiteralError.symbols create mode 100644 tests/baselines/reference/octalIntegerLiteralError.types create mode 100644 tests/baselines/reference/octalLiteralInStrictModeES3.symbols create mode 100644 tests/baselines/reference/octalLiteralInStrictModeES3.types create mode 100644 tests/baselines/reference/operatorAddNullUndefined.symbols create mode 100644 tests/baselines/reference/operatorAddNullUndefined.types create mode 100644 tests/baselines/reference/optionalArgsWithDefaultValues.symbols create mode 100644 tests/baselines/reference/optionalArgsWithDefaultValues.types create mode 100644 tests/baselines/reference/optionalBindingParameters1.symbols create mode 100644 tests/baselines/reference/optionalBindingParameters1.types create mode 100644 tests/baselines/reference/optionalBindingParameters2.symbols create mode 100644 tests/baselines/reference/optionalBindingParameters2.types create mode 100644 tests/baselines/reference/optionalBindingParametersInOverloads1.symbols create mode 100644 tests/baselines/reference/optionalBindingParametersInOverloads1.types create mode 100644 tests/baselines/reference/optionalBindingParametersInOverloads2.symbols create mode 100644 tests/baselines/reference/optionalBindingParametersInOverloads2.types create mode 100644 tests/baselines/reference/optionalFunctionArgAssignability.symbols create mode 100644 tests/baselines/reference/optionalFunctionArgAssignability.types create mode 100644 tests/baselines/reference/optionalParamArgsTest.symbols create mode 100644 tests/baselines/reference/optionalParamArgsTest.types create mode 100644 tests/baselines/reference/optionalParamAssignmentCompat.symbols create mode 100644 tests/baselines/reference/optionalParamAssignmentCompat.types create mode 100644 tests/baselines/reference/optionalParamReferencingOtherParams2.symbols create mode 100644 tests/baselines/reference/optionalParamReferencingOtherParams2.types create mode 100644 tests/baselines/reference/optionalParamReferencingOtherParams3.symbols create mode 100644 tests/baselines/reference/optionalParamReferencingOtherParams3.types create mode 100644 tests/baselines/reference/optionalParamTypeComparison.symbols create mode 100644 tests/baselines/reference/optionalParamTypeComparison.types create mode 100644 tests/baselines/reference/optionalParameterProperty.symbols create mode 100644 tests/baselines/reference/optionalParameterProperty.types create mode 100644 tests/baselines/reference/optionalParamterAndVariableDeclaration2.symbols create mode 100644 tests/baselines/reference/optionalParamterAndVariableDeclaration2.types create mode 100644 tests/baselines/reference/optionalPropertiesInClasses.symbols create mode 100644 tests/baselines/reference/optionalPropertiesInClasses.types create mode 100644 tests/baselines/reference/optionalPropertiesSyntax.symbols create mode 100644 tests/baselines/reference/optionalPropertiesSyntax.types create mode 100644 tests/baselines/reference/optionalPropertiesTest.symbols create mode 100644 tests/baselines/reference/optionalPropertiesTest.types create mode 100644 tests/baselines/reference/optionalSetterParam.symbols create mode 100644 tests/baselines/reference/optionalSetterParam.types create mode 100644 tests/baselines/reference/optionsInlineSourceMapMapRoot.symbols create mode 100644 tests/baselines/reference/optionsInlineSourceMapMapRoot.types create mode 100644 tests/baselines/reference/optionsInlineSourceMapSourcemap.symbols create mode 100644 tests/baselines/reference/optionsInlineSourceMapSourcemap.types create mode 100644 tests/baselines/reference/optionsOutAndNoModuleGen.symbols create mode 100644 tests/baselines/reference/optionsOutAndNoModuleGen.types create mode 100644 tests/baselines/reference/orderMattersForSignatureGroupIdentity.symbols create mode 100644 tests/baselines/reference/orderMattersForSignatureGroupIdentity.types create mode 100644 tests/baselines/reference/out-flag2.symbols create mode 100644 tests/baselines/reference/out-flag2.types create mode 100644 tests/baselines/reference/out-flag3.symbols create mode 100644 tests/baselines/reference/out-flag3.types create mode 100644 tests/baselines/reference/outModuleConcatCommonjs.symbols create mode 100644 tests/baselines/reference/outModuleConcatCommonjs.types create mode 100644 tests/baselines/reference/outModuleConcatES6.symbols create mode 100644 tests/baselines/reference/outModuleConcatES6.types create mode 100644 tests/baselines/reference/outModuleConcatUmd.symbols create mode 100644 tests/baselines/reference/outModuleConcatUmd.types create mode 100644 tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.symbols create mode 100644 tests/baselines/reference/outModuleConcatUnspecifiedModuleKind.types create mode 100644 tests/baselines/reference/overEagerReturnTypeSpecialization.symbols create mode 100644 tests/baselines/reference/overEagerReturnTypeSpecialization.types create mode 100644 tests/baselines/reference/overload1.symbols create mode 100644 tests/baselines/reference/overload1.types create mode 100644 tests/baselines/reference/overloadAssignmentCompat.symbols create mode 100644 tests/baselines/reference/overloadAssignmentCompat.types create mode 100644 tests/baselines/reference/overloadConsecutiveness.symbols create mode 100644 tests/baselines/reference/overloadConsecutiveness.types create mode 100644 tests/baselines/reference/overloadModifiersMustAgree.symbols create mode 100644 tests/baselines/reference/overloadModifiersMustAgree.types create mode 100644 tests/baselines/reference/overloadOnConstInheritance2.symbols create mode 100644 tests/baselines/reference/overloadOnConstInheritance2.types create mode 100644 tests/baselines/reference/overloadOnConstNoAnyImplementation.symbols create mode 100644 tests/baselines/reference/overloadOnConstNoAnyImplementation.types create mode 100644 tests/baselines/reference/overloadOnConstNoAnyImplementation2.symbols create mode 100644 tests/baselines/reference/overloadOnConstNoAnyImplementation2.types create mode 100644 tests/baselines/reference/overloadOnConstNoStringImplementation2.symbols create mode 100644 tests/baselines/reference/overloadOnConstNoStringImplementation2.types create mode 100644 tests/baselines/reference/overloadOnConstantsInvalidOverload1.symbols create mode 100644 tests/baselines/reference/overloadOnConstantsInvalidOverload1.types create mode 100644 tests/baselines/reference/overloadResolution.symbols create mode 100644 tests/baselines/reference/overloadResolution.types create mode 100644 tests/baselines/reference/overloadResolutionClassConstructors.symbols create mode 100644 tests/baselines/reference/overloadResolutionClassConstructors.types create mode 100644 tests/baselines/reference/overloadResolutionConstructors.symbols create mode 100644 tests/baselines/reference/overloadResolutionConstructors.types create mode 100644 tests/baselines/reference/overloadResolutionOnDefaultConstructor1.symbols create mode 100644 tests/baselines/reference/overloadResolutionOnDefaultConstructor1.types create mode 100644 tests/baselines/reference/overloadResolutionOverCTLambda.symbols create mode 100644 tests/baselines/reference/overloadResolutionOverCTLambda.types create mode 100644 tests/baselines/reference/overloadResolutionTest1.symbols create mode 100644 tests/baselines/reference/overloadResolutionTest1.types create mode 100644 tests/baselines/reference/overloadingOnConstants1.symbols create mode 100644 tests/baselines/reference/overloadingOnConstants1.types create mode 100644 tests/baselines/reference/overloadingOnConstants2.symbols create mode 100644 tests/baselines/reference/overloadingOnConstants2.types create mode 100644 tests/baselines/reference/overloadingStaticFunctionsInFunctions.symbols create mode 100644 tests/baselines/reference/overloadingStaticFunctionsInFunctions.types create mode 100644 tests/baselines/reference/overloadresolutionWithConstraintCheckingDeferred.symbols create mode 100644 tests/baselines/reference/overloadresolutionWithConstraintCheckingDeferred.types create mode 100644 tests/baselines/reference/overloadsAndTypeArgumentArityErrors.symbols create mode 100644 tests/baselines/reference/overloadsAndTypeArgumentArityErrors.types create mode 100644 tests/baselines/reference/overloadsInDifferentContainersDisagreeOnAmbient.symbols create mode 100644 tests/baselines/reference/overloadsInDifferentContainersDisagreeOnAmbient.types create mode 100644 tests/baselines/reference/overloadsWithProvisionalErrors.symbols create mode 100644 tests/baselines/reference/overloadsWithProvisionalErrors.types create mode 100644 tests/baselines/reference/overloadsWithinClasses.symbols create mode 100644 tests/baselines/reference/overloadsWithinClasses.types create mode 100644 tests/baselines/reference/overridingPrivateStaticMembers.symbols create mode 100644 tests/baselines/reference/overridingPrivateStaticMembers.types create mode 100644 tests/baselines/reference/packageJsonMain_isNonRecursive.symbols create mode 100644 tests/baselines/reference/packageJsonMain_isNonRecursive.types create mode 100644 tests/baselines/reference/paramPropertiesInSignatures.symbols create mode 100644 tests/baselines/reference/paramPropertiesInSignatures.types create mode 100644 tests/baselines/reference/parameterInitializersForwardReferencing.symbols create mode 100644 tests/baselines/reference/parameterInitializersForwardReferencing.types create mode 100644 tests/baselines/reference/parameterNamesInTypeParameterList.symbols create mode 100644 tests/baselines/reference/parameterNamesInTypeParameterList.types create mode 100644 tests/baselines/reference/parameterPropertyInConstructor1.symbols create mode 100644 tests/baselines/reference/parameterPropertyInConstructor1.types create mode 100644 tests/baselines/reference/parameterPropertyInConstructor2.symbols create mode 100644 tests/baselines/reference/parameterPropertyInConstructor2.types create mode 100644 tests/baselines/reference/parameterPropertyOutsideConstructor.symbols create mode 100644 tests/baselines/reference/parameterPropertyOutsideConstructor.types create mode 100644 tests/baselines/reference/parse1.symbols create mode 100644 tests/baselines/reference/parse1.types create mode 100644 tests/baselines/reference/parse2.symbols create mode 100644 tests/baselines/reference/parse2.types create mode 100644 tests/baselines/reference/parseClassDeclarationInStrictModeByDefaultInES6.symbols create mode 100644 tests/baselines/reference/parseClassDeclarationInStrictModeByDefaultInES6.types create mode 100644 tests/baselines/reference/parseCommaSeperatedNewlineNew.symbols create mode 100644 tests/baselines/reference/parseCommaSeperatedNewlineNew.types create mode 100644 tests/baselines/reference/parseCommaSeperatedNewlineNumber.symbols create mode 100644 tests/baselines/reference/parseCommaSeperatedNewlineNumber.types create mode 100644 tests/baselines/reference/parseCommaSeperatedNewlineString.symbols create mode 100644 tests/baselines/reference/parseCommaSeperatedNewlineString.types create mode 100644 tests/baselines/reference/parseErrorInHeritageClause1.symbols create mode 100644 tests/baselines/reference/parseErrorInHeritageClause1.types create mode 100644 tests/baselines/reference/parseErrorIncorrectReturnToken.symbols create mode 100644 tests/baselines/reference/parseErrorIncorrectReturnToken.types create mode 100644 tests/baselines/reference/parseIncompleteBinaryExpression1.symbols create mode 100644 tests/baselines/reference/parseIncompleteBinaryExpression1.types create mode 100644 tests/baselines/reference/parseRegularExpressionMixedWithComments.symbols create mode 100644 tests/baselines/reference/parseRegularExpressionMixedWithComments.types create mode 100644 tests/baselines/reference/parseTypes.symbols create mode 100644 tests/baselines/reference/parseTypes.types create mode 100644 tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.symbols create mode 100644 tests/baselines/reference/parser.asyncGenerators.classMethods.esnext.types create mode 100644 tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.symbols create mode 100644 tests/baselines/reference/parser.asyncGenerators.functionDeclarations.esnext.types create mode 100644 tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.symbols create mode 100644 tests/baselines/reference/parser.asyncGenerators.functionExpressions.esnext.types create mode 100644 tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.symbols create mode 100644 tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.esnext.types create mode 100644 tests/baselines/reference/parser.forAwait.esnext.symbols create mode 100644 tests/baselines/reference/parser.forAwait.esnext.types create mode 100644 tests/baselines/reference/parser0_004152.symbols create mode 100644 tests/baselines/reference/parser0_004152.types create mode 100644 tests/baselines/reference/parser10.1.1-8gs.symbols create mode 100644 tests/baselines/reference/parser10.1.1-8gs.types create mode 100644 tests/baselines/reference/parser15.4.4.14-9-2.symbols create mode 100644 tests/baselines/reference/parser15.4.4.14-9-2.types create mode 100644 tests/baselines/reference/parser509534.symbols create mode 100644 tests/baselines/reference/parser509534.types create mode 100644 tests/baselines/reference/parser509618.symbols create mode 100644 tests/baselines/reference/parser509618.types create mode 100644 tests/baselines/reference/parser509630.symbols create mode 100644 tests/baselines/reference/parser509630.types create mode 100644 tests/baselines/reference/parser509667.symbols create mode 100644 tests/baselines/reference/parser509667.types create mode 100644 tests/baselines/reference/parser509668.symbols create mode 100644 tests/baselines/reference/parser509668.types create mode 100644 tests/baselines/reference/parser509669.symbols create mode 100644 tests/baselines/reference/parser509669.types create mode 100644 tests/baselines/reference/parser509693.symbols create mode 100644 tests/baselines/reference/parser509693.types create mode 100644 tests/baselines/reference/parser509698.symbols create mode 100644 tests/baselines/reference/parser509698.types create mode 100644 tests/baselines/reference/parser512084.symbols create mode 100644 tests/baselines/reference/parser512084.types create mode 100644 tests/baselines/reference/parser512097.symbols create mode 100644 tests/baselines/reference/parser512097.types create mode 100644 tests/baselines/reference/parser512325.symbols create mode 100644 tests/baselines/reference/parser512325.types create mode 100644 tests/baselines/reference/parser519458.symbols create mode 100644 tests/baselines/reference/parser519458.types create mode 100644 tests/baselines/reference/parser521128.symbols create mode 100644 tests/baselines/reference/parser521128.types create mode 100644 tests/baselines/reference/parser536727.symbols create mode 100644 tests/baselines/reference/parser536727.types create mode 100644 tests/baselines/reference/parser553699.symbols create mode 100644 tests/baselines/reference/parser553699.types create mode 100644 tests/baselines/reference/parser566700.symbols create mode 100644 tests/baselines/reference/parser566700.types create mode 100644 tests/baselines/reference/parser585151.symbols create mode 100644 tests/baselines/reference/parser585151.types create mode 100644 tests/baselines/reference/parser618973.symbols create mode 100644 tests/baselines/reference/parser618973.types create mode 100644 tests/baselines/reference/parser642331.symbols create mode 100644 tests/baselines/reference/parser642331.types create mode 100644 tests/baselines/reference/parser642331_1.symbols create mode 100644 tests/baselines/reference/parser642331_1.types create mode 100644 tests/baselines/reference/parser645086_1.symbols create mode 100644 tests/baselines/reference/parser645086_1.types create mode 100644 tests/baselines/reference/parser645086_2.symbols create mode 100644 tests/baselines/reference/parser645086_2.types create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic1.symbols create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic1.types create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic10.symbols create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic10.types create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic6.symbols create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic6.types create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic7.symbols create mode 100644 tests/baselines/reference/parserAccessibilityAfterStatic7.types create mode 100644 tests/baselines/reference/parserAccessors1.symbols create mode 100644 tests/baselines/reference/parserAccessors1.types create mode 100644 tests/baselines/reference/parserAccessors10.symbols create mode 100644 tests/baselines/reference/parserAccessors10.types create mode 100644 tests/baselines/reference/parserAccessors3.symbols create mode 100644 tests/baselines/reference/parserAccessors3.types create mode 100644 tests/baselines/reference/parserAccessors5.symbols create mode 100644 tests/baselines/reference/parserAccessors5.types create mode 100644 tests/baselines/reference/parserAccessors6.symbols create mode 100644 tests/baselines/reference/parserAccessors6.types create mode 100644 tests/baselines/reference/parserAccessors7.symbols create mode 100644 tests/baselines/reference/parserAccessors7.types create mode 100644 tests/baselines/reference/parserAccessors8.symbols create mode 100644 tests/baselines/reference/parserAccessors8.types create mode 100644 tests/baselines/reference/parserAccessors9.symbols create mode 100644 tests/baselines/reference/parserAccessors9.types create mode 100644 tests/baselines/reference/parserAdditiveExpression1.symbols create mode 100644 tests/baselines/reference/parserAdditiveExpression1.types create mode 100644 tests/baselines/reference/parserAmbiguity1.symbols create mode 100644 tests/baselines/reference/parserAmbiguity1.types create mode 100644 tests/baselines/reference/parserAmbiguity2.symbols create mode 100644 tests/baselines/reference/parserAmbiguity2.types create mode 100644 tests/baselines/reference/parserAmbiguity3.symbols create mode 100644 tests/baselines/reference/parserAmbiguity3.types create mode 100644 tests/baselines/reference/parserAmbiguityWithBinaryOperator4.symbols create mode 100644 tests/baselines/reference/parserAmbiguityWithBinaryOperator4.types create mode 100644 tests/baselines/reference/parserArgumentList1.symbols create mode 100644 tests/baselines/reference/parserArgumentList1.types create mode 100644 tests/baselines/reference/parserArrowFunctionExpression1.symbols create mode 100644 tests/baselines/reference/parserArrowFunctionExpression1.types create mode 100644 tests/baselines/reference/parserArrowFunctionExpression2.symbols create mode 100644 tests/baselines/reference/parserArrowFunctionExpression2.types create mode 100644 tests/baselines/reference/parserArrowFunctionExpression3.symbols create mode 100644 tests/baselines/reference/parserArrowFunctionExpression3.types create mode 100644 tests/baselines/reference/parserArrowFunctionExpression4.symbols create mode 100644 tests/baselines/reference/parserArrowFunctionExpression4.types create mode 100644 tests/baselines/reference/parserAssignmentExpression1.symbols create mode 100644 tests/baselines/reference/parserAssignmentExpression1.types create mode 100644 tests/baselines/reference/parserAstSpans1.symbols create mode 100644 tests/baselines/reference/parserAstSpans1.types create mode 100644 tests/baselines/reference/parserAutomaticSemicolonInsertion1.symbols create mode 100644 tests/baselines/reference/parserAutomaticSemicolonInsertion1.types create mode 100644 tests/baselines/reference/parserBlockStatement1.d.symbols create mode 100644 tests/baselines/reference/parserBlockStatement1.d.types create mode 100644 tests/baselines/reference/parserBreakStatement1.d.symbols create mode 100644 tests/baselines/reference/parserBreakStatement1.d.types create mode 100644 tests/baselines/reference/parserCastVersusArrowFunction1.symbols create mode 100644 tests/baselines/reference/parserCastVersusArrowFunction1.types create mode 100644 tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.symbols create mode 100644 tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.types create mode 100644 tests/baselines/reference/parserClass1.symbols create mode 100644 tests/baselines/reference/parserClass1.types create mode 100644 tests/baselines/reference/parserClass2.symbols create mode 100644 tests/baselines/reference/parserClass2.types create mode 100644 tests/baselines/reference/parserClassDeclaration1.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration1.types create mode 100644 tests/baselines/reference/parserClassDeclaration10.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration10.types create mode 100644 tests/baselines/reference/parserClassDeclaration11.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration11.types create mode 100644 tests/baselines/reference/parserClassDeclaration12.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration12.types create mode 100644 tests/baselines/reference/parserClassDeclaration13.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration13.types create mode 100644 tests/baselines/reference/parserClassDeclaration14.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration14.types create mode 100644 tests/baselines/reference/parserClassDeclaration15.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration15.types create mode 100644 tests/baselines/reference/parserClassDeclaration18.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration18.types create mode 100644 tests/baselines/reference/parserClassDeclaration2.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration2.types create mode 100644 tests/baselines/reference/parserClassDeclaration21.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration21.types create mode 100644 tests/baselines/reference/parserClassDeclaration22.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration22.types create mode 100644 tests/baselines/reference/parserClassDeclaration24.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration24.types create mode 100644 tests/baselines/reference/parserClassDeclaration25.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration25.types create mode 100644 tests/baselines/reference/parserClassDeclaration3.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration3.types create mode 100644 tests/baselines/reference/parserClassDeclaration4.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration4.types create mode 100644 tests/baselines/reference/parserClassDeclaration5.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration5.types create mode 100644 tests/baselines/reference/parserClassDeclaration6.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration6.types create mode 100644 tests/baselines/reference/parserClassDeclaration7.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration7.types create mode 100644 tests/baselines/reference/parserClassDeclaration8.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration8.types create mode 100644 tests/baselines/reference/parserClassDeclaration9.symbols create mode 100644 tests/baselines/reference/parserClassDeclaration9.types create mode 100644 tests/baselines/reference/parserCommaInTypeMemberList2.symbols create mode 100644 tests/baselines/reference/parserCommaInTypeMemberList2.types create mode 100644 tests/baselines/reference/parserComputedPropertyName1.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName1.types create mode 100644 tests/baselines/reference/parserComputedPropertyName10.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName10.types create mode 100644 tests/baselines/reference/parserComputedPropertyName11.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName11.types create mode 100644 tests/baselines/reference/parserComputedPropertyName12.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName12.types create mode 100644 tests/baselines/reference/parserComputedPropertyName13.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName13.types create mode 100644 tests/baselines/reference/parserComputedPropertyName14.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName14.types create mode 100644 tests/baselines/reference/parserComputedPropertyName15.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName15.types create mode 100644 tests/baselines/reference/parserComputedPropertyName16.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName16.types create mode 100644 tests/baselines/reference/parserComputedPropertyName17.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName17.types create mode 100644 tests/baselines/reference/parserComputedPropertyName18.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName18.types create mode 100644 tests/baselines/reference/parserComputedPropertyName19.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName19.types create mode 100644 tests/baselines/reference/parserComputedPropertyName2.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName2.types create mode 100644 tests/baselines/reference/parserComputedPropertyName20.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName20.types create mode 100644 tests/baselines/reference/parserComputedPropertyName21.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName21.types create mode 100644 tests/baselines/reference/parserComputedPropertyName22.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName22.types create mode 100644 tests/baselines/reference/parserComputedPropertyName23.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName23.types create mode 100644 tests/baselines/reference/parserComputedPropertyName24.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName24.types create mode 100644 tests/baselines/reference/parserComputedPropertyName25.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName25.types create mode 100644 tests/baselines/reference/parserComputedPropertyName26.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName26.types create mode 100644 tests/baselines/reference/parserComputedPropertyName27.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName27.types create mode 100644 tests/baselines/reference/parserComputedPropertyName28.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName28.types create mode 100644 tests/baselines/reference/parserComputedPropertyName29.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName29.types create mode 100644 tests/baselines/reference/parserComputedPropertyName3.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName3.types create mode 100644 tests/baselines/reference/parserComputedPropertyName30.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName30.types create mode 100644 tests/baselines/reference/parserComputedPropertyName31.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName31.types create mode 100644 tests/baselines/reference/parserComputedPropertyName32.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName32.types create mode 100644 tests/baselines/reference/parserComputedPropertyName33.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName33.types create mode 100644 tests/baselines/reference/parserComputedPropertyName34.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName34.types create mode 100644 tests/baselines/reference/parserComputedPropertyName35.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName35.types create mode 100644 tests/baselines/reference/parserComputedPropertyName36.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName36.types create mode 100644 tests/baselines/reference/parserComputedPropertyName37.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName37.types create mode 100644 tests/baselines/reference/parserComputedPropertyName38.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName38.types create mode 100644 tests/baselines/reference/parserComputedPropertyName39.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName39.types create mode 100644 tests/baselines/reference/parserComputedPropertyName4.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName4.types create mode 100644 tests/baselines/reference/parserComputedPropertyName40.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName40.types create mode 100644 tests/baselines/reference/parserComputedPropertyName41.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName41.types create mode 100644 tests/baselines/reference/parserComputedPropertyName5.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName5.types create mode 100644 tests/baselines/reference/parserComputedPropertyName6.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName6.types create mode 100644 tests/baselines/reference/parserComputedPropertyName7.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName7.types create mode 100644 tests/baselines/reference/parserComputedPropertyName8.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName8.types create mode 100644 tests/baselines/reference/parserComputedPropertyName9.symbols create mode 100644 tests/baselines/reference/parserComputedPropertyName9.types create mode 100644 tests/baselines/reference/parserConditionalExpression1.symbols create mode 100644 tests/baselines/reference/parserConditionalExpression1.types create mode 100644 tests/baselines/reference/parserConstructorAmbiguity1.symbols create mode 100644 tests/baselines/reference/parserConstructorAmbiguity1.types create mode 100644 tests/baselines/reference/parserConstructorAmbiguity2.symbols create mode 100644 tests/baselines/reference/parserConstructorAmbiguity2.types create mode 100644 tests/baselines/reference/parserConstructorAmbiguity3.symbols create mode 100644 tests/baselines/reference/parserConstructorAmbiguity3.types create mode 100644 tests/baselines/reference/parserConstructorAmbiguity4.symbols create mode 100644 tests/baselines/reference/parserConstructorAmbiguity4.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration10.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration10.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration11.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration11.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration12.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration12.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration2.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration2.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration3.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration3.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration4.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration4.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration6.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration6.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration7.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration7.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration8.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration8.types create mode 100644 tests/baselines/reference/parserConstructorDeclaration9.symbols create mode 100644 tests/baselines/reference/parserConstructorDeclaration9.types create mode 100644 tests/baselines/reference/parserContinueStatement1.d.symbols create mode 100644 tests/baselines/reference/parserContinueStatement1.d.types create mode 100644 tests/baselines/reference/parserDebuggerStatement1.d.symbols create mode 100644 tests/baselines/reference/parserDebuggerStatement1.d.types create mode 100644 tests/baselines/reference/parserDoStatement1.d.symbols create mode 100644 tests/baselines/reference/parserDoStatement1.d.types create mode 100644 tests/baselines/reference/parserES3Accessors1.symbols create mode 100644 tests/baselines/reference/parserES3Accessors1.types create mode 100644 tests/baselines/reference/parserES3Accessors2.symbols create mode 100644 tests/baselines/reference/parserES3Accessors2.types create mode 100644 tests/baselines/reference/parserES3Accessors3.symbols create mode 100644 tests/baselines/reference/parserES3Accessors3.types create mode 100644 tests/baselines/reference/parserES3Accessors4.symbols create mode 100644 tests/baselines/reference/parserES3Accessors4.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName1.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName1.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName10.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName10.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName11.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName11.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName2.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName2.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName3.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName3.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName4.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName4.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName5.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName5.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName6.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName6.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName7.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName7.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName8.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName8.types create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName9.symbols create mode 100644 tests/baselines/reference/parserES5ComputedPropertyName9.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement1.d.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement1.d.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement10.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement10.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement11.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement11.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement12.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement12.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement13.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement13.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement14.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement14.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement15.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement15.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement16.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement16.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement2.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement2.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement20.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement20.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement21.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement21.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement3.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement3.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement4.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement4.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement5.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement5.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement6.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement6.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement7.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement7.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement8.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement8.types create mode 100644 tests/baselines/reference/parserES5ForOfStatement9.symbols create mode 100644 tests/baselines/reference/parserES5ForOfStatement9.types create mode 100644 tests/baselines/reference/parserES5SymbolIndexer1.symbols create mode 100644 tests/baselines/reference/parserES5SymbolIndexer1.types create mode 100644 tests/baselines/reference/parserES5SymbolIndexer2.symbols create mode 100644 tests/baselines/reference/parserES5SymbolIndexer2.types create mode 100644 tests/baselines/reference/parserES5SymbolIndexer3.symbols create mode 100644 tests/baselines/reference/parserES5SymbolIndexer3.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty1.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty1.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty2.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty2.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty3.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty3.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty4.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty4.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty5.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty5.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty6.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty6.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty7.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty7.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty8.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty8.types create mode 100644 tests/baselines/reference/parserES5SymbolProperty9.symbols create mode 100644 tests/baselines/reference/parserES5SymbolProperty9.types create mode 100644 tests/baselines/reference/parserEmptyParenthesizedExpression1.symbols create mode 100644 tests/baselines/reference/parserEmptyParenthesizedExpression1.types create mode 100644 tests/baselines/reference/parserEmptyStatement1.d.symbols create mode 100644 tests/baselines/reference/parserEmptyStatement1.d.types create mode 100644 tests/baselines/reference/parserEnum4.symbols create mode 100644 tests/baselines/reference/parserEnum4.types create mode 100644 tests/baselines/reference/parserEnum5.symbols create mode 100644 tests/baselines/reference/parserEnum5.types create mode 100644 tests/baselines/reference/parserEnum7.symbols create mode 100644 tests/baselines/reference/parserEnum7.types create mode 100644 tests/baselines/reference/parserEnumDeclaration2.symbols create mode 100644 tests/baselines/reference/parserEnumDeclaration2.types create mode 100644 tests/baselines/reference/parserEnumDeclaration3.d.symbols create mode 100644 tests/baselines/reference/parserEnumDeclaration3.d.types create mode 100644 tests/baselines/reference/parserEnumDeclaration4.symbols create mode 100644 tests/baselines/reference/parserEnumDeclaration4.types create mode 100644 tests/baselines/reference/parserEqualsGreaterThanAfterFunction1.symbols create mode 100644 tests/baselines/reference/parserEqualsGreaterThanAfterFunction1.types create mode 100644 tests/baselines/reference/parserEqualsGreaterThanAfterFunction2.symbols create mode 100644 tests/baselines/reference/parserEqualsGreaterThanAfterFunction2.types create mode 100644 tests/baselines/reference/parserErrantAccessibilityModifierInModule1.symbols create mode 100644 tests/baselines/reference/parserErrantAccessibilityModifierInModule1.types create mode 100644 tests/baselines/reference/parserErrantEqualsGreaterThanAfterFunction1.symbols create mode 100644 tests/baselines/reference/parserErrantEqualsGreaterThanAfterFunction1.types create mode 100644 tests/baselines/reference/parserErrantEqualsGreaterThanAfterFunction2.symbols create mode 100644 tests/baselines/reference/parserErrantEqualsGreaterThanAfterFunction2.types create mode 100644 tests/baselines/reference/parserErrantSemicolonInClass1.symbols create mode 100644 tests/baselines/reference/parserErrantSemicolonInClass1.types create mode 100644 tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression1.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression1.types create mode 100644 tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression2.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression2.types create mode 100644 tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryArrayLiteralExpression3.types create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement1.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement1.types create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement2.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement2.types create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement3.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement3.types create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement4.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement4.types create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement5.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement5.types create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement6.symbols create mode 100644 tests/baselines/reference/parserErrorRecoveryIfStatement6.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList3.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList3.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList4.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList4.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList6.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList6.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList7.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ArgumentList7.types create mode 100644 tests/baselines/reference/parserErrorRecovery_Block1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_Block1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_Block2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_Block2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_Block3.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_Block3.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ClassElement1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ClassElement1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ClassElement2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ClassElement2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ClassElement3.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ClassElement3.types create mode 100644 tests/baselines/reference/parserErrorRecovery_Expression1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_Expression1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause3.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause3.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause4.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause4.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause5.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause5.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause6.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ExtendsOrImplementsClause6.types create mode 100644 tests/baselines/reference/parserErrorRecovery_IncompleteMemberVariable2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_IncompleteMemberVariable2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_LeftShift1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_LeftShift1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ModuleElement1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ModuleElement1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ModuleElement2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ModuleElement2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral3.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral3.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral4.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral4.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral5.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ObjectLiteral5.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList4.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList4.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList5.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList5.types create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList6.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_ParameterList6.types create mode 100644 tests/baselines/reference/parserErrorRecovery_SourceUnit1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_SourceUnit1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_SwitchStatement1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_SwitchStatement1.types create mode 100644 tests/baselines/reference/parserErrorRecovery_SwitchStatement2.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_SwitchStatement2.types create mode 100644 tests/baselines/reference/parserErrorRecovery_VariableList1.symbols create mode 100644 tests/baselines/reference/parserErrorRecovery_VariableList1.types create mode 100644 tests/baselines/reference/parserExportAssignment1.symbols create mode 100644 tests/baselines/reference/parserExportAssignment1.types create mode 100644 tests/baselines/reference/parserExportAssignment2.symbols create mode 100644 tests/baselines/reference/parserExportAssignment2.types create mode 100644 tests/baselines/reference/parserExportAssignment3.symbols create mode 100644 tests/baselines/reference/parserExportAssignment3.types create mode 100644 tests/baselines/reference/parserExportAssignment4.symbols create mode 100644 tests/baselines/reference/parserExportAssignment4.types create mode 100644 tests/baselines/reference/parserExportAssignment5.symbols create mode 100644 tests/baselines/reference/parserExportAssignment5.types create mode 100644 tests/baselines/reference/parserExportAssignment6.symbols create mode 100644 tests/baselines/reference/parserExportAssignment6.types create mode 100644 tests/baselines/reference/parserExportAssignment7.symbols create mode 100644 tests/baselines/reference/parserExportAssignment7.types create mode 100644 tests/baselines/reference/parserExportAssignment8.symbols create mode 100644 tests/baselines/reference/parserExportAssignment8.types create mode 100644 tests/baselines/reference/parserExportAssignment9.symbols create mode 100644 tests/baselines/reference/parserExportAssignment9.types create mode 100644 tests/baselines/reference/parserExpressionStatement1.d.symbols create mode 100644 tests/baselines/reference/parserExpressionStatement1.d.types create mode 100644 tests/baselines/reference/parserForInStatement1.d.symbols create mode 100644 tests/baselines/reference/parserForInStatement1.d.types create mode 100644 tests/baselines/reference/parserForInStatement2.symbols create mode 100644 tests/baselines/reference/parserForInStatement2.types create mode 100644 tests/baselines/reference/parserForInStatement3.symbols create mode 100644 tests/baselines/reference/parserForInStatement3.types create mode 100644 tests/baselines/reference/parserForInStatement4.symbols create mode 100644 tests/baselines/reference/parserForInStatement4.types create mode 100644 tests/baselines/reference/parserForInStatement5.symbols create mode 100644 tests/baselines/reference/parserForInStatement5.types create mode 100644 tests/baselines/reference/parserForInStatement6.symbols create mode 100644 tests/baselines/reference/parserForInStatement6.types create mode 100644 tests/baselines/reference/parserForInStatement7.symbols create mode 100644 tests/baselines/reference/parserForInStatement7.types create mode 100644 tests/baselines/reference/parserForOfStatement1.d.symbols create mode 100644 tests/baselines/reference/parserForOfStatement1.d.types create mode 100644 tests/baselines/reference/parserForOfStatement10.symbols create mode 100644 tests/baselines/reference/parserForOfStatement10.types create mode 100644 tests/baselines/reference/parserForOfStatement11.symbols create mode 100644 tests/baselines/reference/parserForOfStatement11.types create mode 100644 tests/baselines/reference/parserForOfStatement12.symbols create mode 100644 tests/baselines/reference/parserForOfStatement12.types create mode 100644 tests/baselines/reference/parserForOfStatement13.symbols create mode 100644 tests/baselines/reference/parserForOfStatement13.types create mode 100644 tests/baselines/reference/parserForOfStatement14.symbols create mode 100644 tests/baselines/reference/parserForOfStatement14.types create mode 100644 tests/baselines/reference/parserForOfStatement15.symbols create mode 100644 tests/baselines/reference/parserForOfStatement15.types create mode 100644 tests/baselines/reference/parserForOfStatement16.symbols create mode 100644 tests/baselines/reference/parserForOfStatement16.types create mode 100644 tests/baselines/reference/parserForOfStatement2.symbols create mode 100644 tests/baselines/reference/parserForOfStatement2.types create mode 100644 tests/baselines/reference/parserForOfStatement20.symbols create mode 100644 tests/baselines/reference/parserForOfStatement20.types create mode 100644 tests/baselines/reference/parserForOfStatement21.symbols create mode 100644 tests/baselines/reference/parserForOfStatement21.types create mode 100644 tests/baselines/reference/parserForOfStatement3.symbols create mode 100644 tests/baselines/reference/parserForOfStatement3.types create mode 100644 tests/baselines/reference/parserForOfStatement4.symbols create mode 100644 tests/baselines/reference/parserForOfStatement4.types create mode 100644 tests/baselines/reference/parserForOfStatement5.symbols create mode 100644 tests/baselines/reference/parserForOfStatement5.types create mode 100644 tests/baselines/reference/parserForOfStatement6.symbols create mode 100644 tests/baselines/reference/parserForOfStatement6.types create mode 100644 tests/baselines/reference/parserForOfStatement7.symbols create mode 100644 tests/baselines/reference/parserForOfStatement7.types create mode 100644 tests/baselines/reference/parserForOfStatement8.symbols create mode 100644 tests/baselines/reference/parserForOfStatement8.types create mode 100644 tests/baselines/reference/parserForOfStatement9.symbols create mode 100644 tests/baselines/reference/parserForOfStatement9.types create mode 100644 tests/baselines/reference/parserForStatement1.d.symbols create mode 100644 tests/baselines/reference/parserForStatement1.d.types create mode 100644 tests/baselines/reference/parserForStatement2.symbols create mode 100644 tests/baselines/reference/parserForStatement2.types create mode 100644 tests/baselines/reference/parserForStatement3.symbols create mode 100644 tests/baselines/reference/parserForStatement3.types create mode 100644 tests/baselines/reference/parserForStatement4.symbols create mode 100644 tests/baselines/reference/parserForStatement4.types create mode 100644 tests/baselines/reference/parserForStatement5.symbols create mode 100644 tests/baselines/reference/parserForStatement5.types create mode 100644 tests/baselines/reference/parserForStatement6.symbols create mode 100644 tests/baselines/reference/parserForStatement6.types create mode 100644 tests/baselines/reference/parserForStatement7.symbols create mode 100644 tests/baselines/reference/parserForStatement7.types create mode 100644 tests/baselines/reference/parserForStatement8.symbols create mode 100644 tests/baselines/reference/parserForStatement8.types create mode 100644 tests/baselines/reference/parserFunctionDeclaration1.symbols create mode 100644 tests/baselines/reference/parserFunctionDeclaration1.types create mode 100644 tests/baselines/reference/parserFunctionDeclaration2.d.symbols create mode 100644 tests/baselines/reference/parserFunctionDeclaration2.d.types create mode 100644 tests/baselines/reference/parserFunctionDeclaration2.symbols create mode 100644 tests/baselines/reference/parserFunctionDeclaration2.types create mode 100644 tests/baselines/reference/parserFunctionDeclaration3.symbols create mode 100644 tests/baselines/reference/parserFunctionDeclaration3.types create mode 100644 tests/baselines/reference/parserFunctionDeclaration4.symbols create mode 100644 tests/baselines/reference/parserFunctionDeclaration4.types create mode 100644 tests/baselines/reference/parserFunctionDeclaration6.symbols create mode 100644 tests/baselines/reference/parserFunctionDeclaration6.types create mode 100644 tests/baselines/reference/parserFunctionDeclaration7.symbols create mode 100644 tests/baselines/reference/parserFunctionDeclaration7.types create mode 100644 tests/baselines/reference/parserFuzz1.symbols create mode 100644 tests/baselines/reference/parserFuzz1.types create mode 100644 tests/baselines/reference/parserGenericConstraint2.symbols create mode 100644 tests/baselines/reference/parserGenericConstraint2.types create mode 100644 tests/baselines/reference/parserGenericConstraint3.symbols create mode 100644 tests/baselines/reference/parserGenericConstraint3.types create mode 100644 tests/baselines/reference/parserGenericConstraint4.symbols create mode 100644 tests/baselines/reference/parserGenericConstraint4.types create mode 100644 tests/baselines/reference/parserGenericConstraint5.symbols create mode 100644 tests/baselines/reference/parserGenericConstraint5.types create mode 100644 tests/baselines/reference/parserGenericConstraint6.symbols create mode 100644 tests/baselines/reference/parserGenericConstraint6.types create mode 100644 tests/baselines/reference/parserGenericConstraint7.symbols create mode 100644 tests/baselines/reference/parserGenericConstraint7.types create mode 100644 tests/baselines/reference/parserGenericsInInterfaceDeclaration1.symbols create mode 100644 tests/baselines/reference/parserGenericsInInterfaceDeclaration1.types create mode 100644 tests/baselines/reference/parserGenericsInTypeContexts1.symbols create mode 100644 tests/baselines/reference/parserGenericsInTypeContexts1.types create mode 100644 tests/baselines/reference/parserGenericsInTypeContexts2.symbols create mode 100644 tests/baselines/reference/parserGenericsInTypeContexts2.types create mode 100644 tests/baselines/reference/parserGenericsInVariableDeclaration1.symbols create mode 100644 tests/baselines/reference/parserGenericsInVariableDeclaration1.types create mode 100644 tests/baselines/reference/parserGetAccessorWithTypeParameters1.symbols create mode 100644 tests/baselines/reference/parserGetAccessorWithTypeParameters1.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity11.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity11.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity12.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity12.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity13.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity13.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity14.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity14.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity15.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity15.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity16.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity16.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity17.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity17.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity18.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity18.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity19.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity19.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity2.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity2.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity20.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity20.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity3.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity3.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity4.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity4.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity7.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity7.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity8.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity8.types create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity9.symbols create mode 100644 tests/baselines/reference/parserGreaterThanTokenAmbiguity9.types create mode 100644 tests/baselines/reference/parserIfStatement1.d.symbols create mode 100644 tests/baselines/reference/parserIfStatement1.d.types create mode 100644 tests/baselines/reference/parserIfStatement2.symbols create mode 100644 tests/baselines/reference/parserIfStatement2.types create mode 100644 tests/baselines/reference/parserImportDeclaration1.symbols create mode 100644 tests/baselines/reference/parserImportDeclaration1.types create mode 100644 tests/baselines/reference/parserInExpression1.symbols create mode 100644 tests/baselines/reference/parserInExpression1.types create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration10.symbols create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration10.types create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration5.symbols create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration5.types create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration6.symbols create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration6.types create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration7.symbols create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration7.types create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration8.symbols create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration8.types create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration9.symbols create mode 100644 tests/baselines/reference/parserIndexMemberDeclaration9.types create mode 100644 tests/baselines/reference/parserIndexSignature1.symbols create mode 100644 tests/baselines/reference/parserIndexSignature1.types create mode 100644 tests/baselines/reference/parserIndexSignature10.symbols create mode 100644 tests/baselines/reference/parserIndexSignature10.types create mode 100644 tests/baselines/reference/parserIndexSignature11.symbols create mode 100644 tests/baselines/reference/parserIndexSignature11.types create mode 100644 tests/baselines/reference/parserIndexSignature2.symbols create mode 100644 tests/baselines/reference/parserIndexSignature2.types create mode 100644 tests/baselines/reference/parserIndexSignature3.symbols create mode 100644 tests/baselines/reference/parserIndexSignature3.types create mode 100644 tests/baselines/reference/parserIndexSignature4.symbols create mode 100644 tests/baselines/reference/parserIndexSignature4.types create mode 100644 tests/baselines/reference/parserIndexSignature5.symbols create mode 100644 tests/baselines/reference/parserIndexSignature5.types create mode 100644 tests/baselines/reference/parserIndexSignature6.symbols create mode 100644 tests/baselines/reference/parserIndexSignature6.types create mode 100644 tests/baselines/reference/parserIndexSignature7.symbols create mode 100644 tests/baselines/reference/parserIndexSignature7.types create mode 100644 tests/baselines/reference/parserIndexSignature8.symbols create mode 100644 tests/baselines/reference/parserIndexSignature8.types create mode 100644 tests/baselines/reference/parserIndexSignature9.symbols create mode 100644 tests/baselines/reference/parserIndexSignature9.types create mode 100644 tests/baselines/reference/parserInterfaceDeclaration1.symbols create mode 100644 tests/baselines/reference/parserInterfaceDeclaration1.types create mode 100644 tests/baselines/reference/parserInterfaceDeclaration2.symbols create mode 100644 tests/baselines/reference/parserInterfaceDeclaration2.types create mode 100644 tests/baselines/reference/parserInterfaceDeclaration3.symbols create mode 100644 tests/baselines/reference/parserInterfaceDeclaration3.types create mode 100644 tests/baselines/reference/parserInterfaceDeclaration4.symbols create mode 100644 tests/baselines/reference/parserInterfaceDeclaration4.types create mode 100644 tests/baselines/reference/parserInterfaceDeclaration6.symbols create mode 100644 tests/baselines/reference/parserInterfaceDeclaration6.types create mode 100644 tests/baselines/reference/parserInterfaceDeclaration8.symbols create mode 100644 tests/baselines/reference/parserInterfaceDeclaration8.types create mode 100644 tests/baselines/reference/parserInvalidIdentifiersInVariableStatements1.symbols create mode 100644 tests/baselines/reference/parserInvalidIdentifiersInVariableStatements1.types create mode 100644 tests/baselines/reference/parserInvocationOfMemberAccessOffOfObjectCreationExpression1.symbols create mode 100644 tests/baselines/reference/parserInvocationOfMemberAccessOffOfObjectCreationExpression1.types create mode 100644 tests/baselines/reference/parserKeywordsAsIdentifierName2.symbols create mode 100644 tests/baselines/reference/parserKeywordsAsIdentifierName2.types create mode 100644 tests/baselines/reference/parserLabeledStatement1.d.symbols create mode 100644 tests/baselines/reference/parserLabeledStatement1.d.types create mode 100644 tests/baselines/reference/parserMemberAccessAfterPostfixExpression1.symbols create mode 100644 tests/baselines/reference/parserMemberAccessAfterPostfixExpression1.types create mode 100644 tests/baselines/reference/parserMemberAccessExpression1.symbols create mode 100644 tests/baselines/reference/parserMemberAccessExpression1.types create mode 100644 tests/baselines/reference/parserMemberAccessOffOfGenericType1.symbols create mode 100644 tests/baselines/reference/parserMemberAccessOffOfGenericType1.types create mode 100644 tests/baselines/reference/parserMemberAccessor1.symbols create mode 100644 tests/baselines/reference/parserMemberAccessor1.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration1.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration1.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration10.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration10.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration11.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration11.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration12.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration12.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration13.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration13.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration14.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration14.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration15.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration15.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration16.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration16.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration17.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration17.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration18.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration18.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration2.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration2.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration3.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration3.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration7.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration7.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration8.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration8.types create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration9.symbols create mode 100644 tests/baselines/reference/parserMemberAccessorDeclaration9.types create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration1.symbols create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration1.types create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration2.symbols create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration2.types create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration3.symbols create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration3.types create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration4.symbols create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration4.types create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration5.symbols create mode 100644 tests/baselines/reference/parserMemberFunctionDeclaration5.types create mode 100644 tests/baselines/reference/parserMemberFunctionDeclarationAmbiguities1.symbols create mode 100644 tests/baselines/reference/parserMemberFunctionDeclarationAmbiguities1.types create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration1.symbols create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration1.types create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration2.symbols create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration2.types create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration3.symbols create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration3.types create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration4.symbols create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration4.types create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration5.symbols create mode 100644 tests/baselines/reference/parserMemberVariableDeclaration5.types create mode 100644 tests/baselines/reference/parserMissingLambdaOpenBrace1.symbols create mode 100644 tests/baselines/reference/parserMissingLambdaOpenBrace1.types create mode 100644 tests/baselines/reference/parserMissingToken1.symbols create mode 100644 tests/baselines/reference/parserMissingToken1.types create mode 100644 tests/baselines/reference/parserMissingToken2.symbols create mode 100644 tests/baselines/reference/parserMissingToken2.types create mode 100644 tests/baselines/reference/parserModifierOnPropertySignature1.symbols create mode 100644 tests/baselines/reference/parserModifierOnPropertySignature1.types create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock1.symbols create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock1.types create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock2.symbols create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock2.types create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock3.symbols create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock3.types create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock4.symbols create mode 100644 tests/baselines/reference/parserModifierOnStatementInBlock4.types create mode 100644 tests/baselines/reference/parserModuleDeclaration1.d.symbols create mode 100644 tests/baselines/reference/parserModuleDeclaration1.d.types create mode 100644 tests/baselines/reference/parserModuleDeclaration1.symbols create mode 100644 tests/baselines/reference/parserModuleDeclaration1.types create mode 100644 tests/baselines/reference/parserModuleDeclaration10.symbols create mode 100644 tests/baselines/reference/parserModuleDeclaration10.types create mode 100644 tests/baselines/reference/parserModuleDeclaration2.d.symbols create mode 100644 tests/baselines/reference/parserModuleDeclaration2.d.types create mode 100644 tests/baselines/reference/parserModuleDeclaration3.symbols create mode 100644 tests/baselines/reference/parserModuleDeclaration3.types create mode 100644 tests/baselines/reference/parserModuleDeclaration4.d.symbols create mode 100644 tests/baselines/reference/parserModuleDeclaration4.d.types create mode 100644 tests/baselines/reference/parserModuleDeclaration5.symbols create mode 100644 tests/baselines/reference/parserModuleDeclaration5.types create mode 100644 tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.symbols create mode 100644 tests/baselines/reference/parserNoASIOnCallAfterFunctionExpression1.types create mode 100644 tests/baselines/reference/parserNotHexLiteral1.symbols create mode 100644 tests/baselines/reference/parserNotHexLiteral1.types create mode 100644 tests/baselines/reference/parserNotRegex1.symbols create mode 100644 tests/baselines/reference/parserNotRegex1.types create mode 100644 tests/baselines/reference/parserObjectCreation1.symbols create mode 100644 tests/baselines/reference/parserObjectCreation1.types create mode 100644 tests/baselines/reference/parserObjectCreation2.symbols create mode 100644 tests/baselines/reference/parserObjectCreation2.types create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral1.symbols create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral1.types create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral2.symbols create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral2.types create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral3.symbols create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral3.types create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral4.symbols create mode 100644 tests/baselines/reference/parserObjectCreationArrayLiteral4.types create mode 100644 tests/baselines/reference/parserObjectType5.symbols create mode 100644 tests/baselines/reference/parserObjectType5.types create mode 100644 tests/baselines/reference/parserObjectType6.symbols create mode 100644 tests/baselines/reference/parserObjectType6.types create mode 100644 tests/baselines/reference/parserOverloadOnConstants1.symbols create mode 100644 tests/baselines/reference/parserOverloadOnConstants1.types create mode 100644 tests/baselines/reference/parserParameterList1.symbols create mode 100644 tests/baselines/reference/parserParameterList1.types create mode 100644 tests/baselines/reference/parserParameterList10.symbols create mode 100644 tests/baselines/reference/parserParameterList10.types create mode 100644 tests/baselines/reference/parserParameterList11.symbols create mode 100644 tests/baselines/reference/parserParameterList11.types create mode 100644 tests/baselines/reference/parserParameterList13.symbols create mode 100644 tests/baselines/reference/parserParameterList13.types create mode 100644 tests/baselines/reference/parserParameterList14.symbols create mode 100644 tests/baselines/reference/parserParameterList14.types create mode 100644 tests/baselines/reference/parserParameterList15.symbols create mode 100644 tests/baselines/reference/parserParameterList15.types create mode 100644 tests/baselines/reference/parserParameterList16.symbols create mode 100644 tests/baselines/reference/parserParameterList16.types create mode 100644 tests/baselines/reference/parserParameterList17.symbols create mode 100644 tests/baselines/reference/parserParameterList17.types create mode 100644 tests/baselines/reference/parserParameterList2.symbols create mode 100644 tests/baselines/reference/parserParameterList2.types create mode 100644 tests/baselines/reference/parserParameterList3.symbols create mode 100644 tests/baselines/reference/parserParameterList3.types create mode 100644 tests/baselines/reference/parserParameterList4.symbols create mode 100644 tests/baselines/reference/parserParameterList4.types create mode 100644 tests/baselines/reference/parserParameterList5.symbols create mode 100644 tests/baselines/reference/parserParameterList5.types create mode 100644 tests/baselines/reference/parserParameterList6.symbols create mode 100644 tests/baselines/reference/parserParameterList6.types create mode 100644 tests/baselines/reference/parserParameterList7.symbols create mode 100644 tests/baselines/reference/parserParameterList7.types create mode 100644 tests/baselines/reference/parserParameterList8.symbols create mode 100644 tests/baselines/reference/parserParameterList8.types create mode 100644 tests/baselines/reference/parserParameterList9.symbols create mode 100644 tests/baselines/reference/parserParameterList9.types create mode 100644 tests/baselines/reference/parserPostfixPostfixExpression1.symbols create mode 100644 tests/baselines/reference/parserPostfixPostfixExpression1.types create mode 100644 tests/baselines/reference/parserPostfixUnaryExpression1.symbols create mode 100644 tests/baselines/reference/parserPostfixUnaryExpression1.types create mode 100644 tests/baselines/reference/parserPublicBreak1.symbols create mode 100644 tests/baselines/reference/parserPublicBreak1.types create mode 100644 tests/baselines/reference/parserRealSource1.symbols create mode 100644 tests/baselines/reference/parserRealSource1.types create mode 100644 tests/baselines/reference/parserRealSource10.symbols create mode 100644 tests/baselines/reference/parserRealSource10.types create mode 100644 tests/baselines/reference/parserRealSource11.symbols create mode 100644 tests/baselines/reference/parserRealSource11.types create mode 100644 tests/baselines/reference/parserRealSource12.symbols create mode 100644 tests/baselines/reference/parserRealSource12.types create mode 100644 tests/baselines/reference/parserRealSource13.symbols create mode 100644 tests/baselines/reference/parserRealSource13.types create mode 100644 tests/baselines/reference/parserRealSource14.symbols create mode 100644 tests/baselines/reference/parserRealSource14.types create mode 100644 tests/baselines/reference/parserRealSource2.symbols create mode 100644 tests/baselines/reference/parserRealSource2.types create mode 100644 tests/baselines/reference/parserRealSource3.symbols create mode 100644 tests/baselines/reference/parserRealSource3.types create mode 100644 tests/baselines/reference/parserRealSource4.symbols create mode 100644 tests/baselines/reference/parserRealSource4.types create mode 100644 tests/baselines/reference/parserRealSource5.symbols create mode 100644 tests/baselines/reference/parserRealSource5.types create mode 100644 tests/baselines/reference/parserRealSource6.symbols create mode 100644 tests/baselines/reference/parserRealSource6.types create mode 100644 tests/baselines/reference/parserRealSource7.symbols create mode 100644 tests/baselines/reference/parserRealSource7.types create mode 100644 tests/baselines/reference/parserRealSource8.symbols create mode 100644 tests/baselines/reference/parserRealSource8.types create mode 100644 tests/baselines/reference/parserRealSource9.symbols create mode 100644 tests/baselines/reference/parserRealSource9.types create mode 100644 tests/baselines/reference/parserRegularExpression1.symbols create mode 100644 tests/baselines/reference/parserRegularExpression1.types create mode 100644 tests/baselines/reference/parserRegularExpression2.symbols create mode 100644 tests/baselines/reference/parserRegularExpression2.types create mode 100644 tests/baselines/reference/parserRegularExpression3.symbols create mode 100644 tests/baselines/reference/parserRegularExpression3.types create mode 100644 tests/baselines/reference/parserRegularExpression4.symbols create mode 100644 tests/baselines/reference/parserRegularExpression4.types create mode 100644 tests/baselines/reference/parserRegularExpression5.symbols create mode 100644 tests/baselines/reference/parserRegularExpression5.types create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity1.symbols create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity1.types create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity2.symbols create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity2.types create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.symbols create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity3.types create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity4.symbols create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity4.types create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity5.symbols create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity5.types create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity7.symbols create mode 100644 tests/baselines/reference/parserRegularExpressionDivideAmbiguity7.types create mode 100644 tests/baselines/reference/parserReturnStatement1.d.symbols create mode 100644 tests/baselines/reference/parserReturnStatement1.d.types create mode 100644 tests/baselines/reference/parserReturnStatement1.symbols create mode 100644 tests/baselines/reference/parserReturnStatement1.types create mode 100644 tests/baselines/reference/parserReturnStatement2.symbols create mode 100644 tests/baselines/reference/parserReturnStatement2.types create mode 100644 tests/baselines/reference/parserReturnStatement4.symbols create mode 100644 tests/baselines/reference/parserReturnStatement4.types create mode 100644 tests/baselines/reference/parserS12.11_A3_T4.symbols create mode 100644 tests/baselines/reference/parserS12.11_A3_T4.types create mode 100644 tests/baselines/reference/parserS7.2_A1.5_T2.symbols create mode 100644 tests/baselines/reference/parserS7.2_A1.5_T2.types create mode 100644 tests/baselines/reference/parserS7.3_A1.1_T2.symbols create mode 100644 tests/baselines/reference/parserS7.3_A1.1_T2.types create mode 100644 tests/baselines/reference/parserS7.6_A4.2_T1.symbols create mode 100644 tests/baselines/reference/parserS7.6_A4.2_T1.types create mode 100644 tests/baselines/reference/parserS7.9_A5.7_T1.symbols create mode 100644 tests/baselines/reference/parserS7.9_A5.7_T1.types create mode 100644 tests/baselines/reference/parserSetAccessorWithTypeAnnotation1.symbols create mode 100644 tests/baselines/reference/parserSetAccessorWithTypeAnnotation1.types create mode 100644 tests/baselines/reference/parserSetAccessorWithTypeParameters1.symbols create mode 100644 tests/baselines/reference/parserSetAccessorWithTypeParameters1.types create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment1.symbols create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment1.types create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment2.symbols create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment2.types create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment3.symbols create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment3.types create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment4.symbols create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment4.types create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment5.symbols create mode 100644 tests/baselines/reference/parserShorthandPropertyAssignment5.types create mode 100644 tests/baselines/reference/parserSkippedTokens1.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens1.types create mode 100644 tests/baselines/reference/parserSkippedTokens10.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens10.types create mode 100644 tests/baselines/reference/parserSkippedTokens11.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens11.types create mode 100644 tests/baselines/reference/parserSkippedTokens12.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens12.types create mode 100644 tests/baselines/reference/parserSkippedTokens13.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens13.types create mode 100644 tests/baselines/reference/parserSkippedTokens14.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens14.types create mode 100644 tests/baselines/reference/parserSkippedTokens15.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens15.types create mode 100644 tests/baselines/reference/parserSkippedTokens16.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens16.types create mode 100644 tests/baselines/reference/parserSkippedTokens17.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens17.types create mode 100644 tests/baselines/reference/parserSkippedTokens18.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens18.types create mode 100644 tests/baselines/reference/parserSkippedTokens19.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens19.types create mode 100644 tests/baselines/reference/parserSkippedTokens2.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens2.types create mode 100644 tests/baselines/reference/parserSkippedTokens20.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens20.types create mode 100644 tests/baselines/reference/parserSkippedTokens3.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens3.types create mode 100644 tests/baselines/reference/parserSkippedTokens4.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens4.types create mode 100644 tests/baselines/reference/parserSkippedTokens5.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens5.types create mode 100644 tests/baselines/reference/parserSkippedTokens6.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens6.types create mode 100644 tests/baselines/reference/parserSkippedTokens7.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens7.types create mode 100644 tests/baselines/reference/parserSkippedTokens8.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens8.types create mode 100644 tests/baselines/reference/parserSkippedTokens9.symbols create mode 100644 tests/baselines/reference/parserSkippedTokens9.types create mode 100644 tests/baselines/reference/parserStatementIsNotAMemberVariableDeclaration1.symbols create mode 100644 tests/baselines/reference/parserStatementIsNotAMemberVariableDeclaration1.types create mode 100644 tests/baselines/reference/parserStrictMode1.symbols create mode 100644 tests/baselines/reference/parserStrictMode1.types create mode 100644 tests/baselines/reference/parserStrictMode10.symbols create mode 100644 tests/baselines/reference/parserStrictMode10.types create mode 100644 tests/baselines/reference/parserStrictMode11.symbols create mode 100644 tests/baselines/reference/parserStrictMode11.types create mode 100644 tests/baselines/reference/parserStrictMode12.symbols create mode 100644 tests/baselines/reference/parserStrictMode12.types create mode 100644 tests/baselines/reference/parserStrictMode13.symbols create mode 100644 tests/baselines/reference/parserStrictMode13.types create mode 100644 tests/baselines/reference/parserStrictMode14.symbols create mode 100644 tests/baselines/reference/parserStrictMode14.types create mode 100644 tests/baselines/reference/parserStrictMode15-negative.symbols create mode 100644 tests/baselines/reference/parserStrictMode15-negative.types create mode 100644 tests/baselines/reference/parserStrictMode15.symbols create mode 100644 tests/baselines/reference/parserStrictMode15.types create mode 100644 tests/baselines/reference/parserStrictMode2.symbols create mode 100644 tests/baselines/reference/parserStrictMode2.types create mode 100644 tests/baselines/reference/parserStrictMode3-negative.symbols create mode 100644 tests/baselines/reference/parserStrictMode3-negative.types create mode 100644 tests/baselines/reference/parserStrictMode3.symbols create mode 100644 tests/baselines/reference/parserStrictMode3.types create mode 100644 tests/baselines/reference/parserStrictMode4.symbols create mode 100644 tests/baselines/reference/parserStrictMode4.types create mode 100644 tests/baselines/reference/parserStrictMode5.symbols create mode 100644 tests/baselines/reference/parserStrictMode5.types create mode 100644 tests/baselines/reference/parserStrictMode6-negative.symbols create mode 100644 tests/baselines/reference/parserStrictMode6-negative.types create mode 100644 tests/baselines/reference/parserStrictMode6.symbols create mode 100644 tests/baselines/reference/parserStrictMode6.types create mode 100644 tests/baselines/reference/parserStrictMode7.symbols create mode 100644 tests/baselines/reference/parserStrictMode7.types create mode 100644 tests/baselines/reference/parserStrictMode8.symbols create mode 100644 tests/baselines/reference/parserStrictMode8.types create mode 100644 tests/baselines/reference/parserStrictMode9.symbols create mode 100644 tests/baselines/reference/parserStrictMode9.types create mode 100644 tests/baselines/reference/parserSuperExpression1.symbols create mode 100644 tests/baselines/reference/parserSuperExpression1.types create mode 100644 tests/baselines/reference/parserSuperExpression2.symbols create mode 100644 tests/baselines/reference/parserSuperExpression2.types create mode 100644 tests/baselines/reference/parserSuperExpression3.symbols create mode 100644 tests/baselines/reference/parserSuperExpression3.types create mode 100644 tests/baselines/reference/parserSuperExpression4.symbols create mode 100644 tests/baselines/reference/parserSuperExpression4.types create mode 100644 tests/baselines/reference/parserSwitchStatement1.d.symbols create mode 100644 tests/baselines/reference/parserSwitchStatement1.d.types create mode 100644 tests/baselines/reference/parserSymbolIndexer1.symbols create mode 100644 tests/baselines/reference/parserSymbolIndexer1.types create mode 100644 tests/baselines/reference/parserSymbolIndexer2.symbols create mode 100644 tests/baselines/reference/parserSymbolIndexer2.types create mode 100644 tests/baselines/reference/parserSymbolIndexer3.symbols create mode 100644 tests/baselines/reference/parserSymbolIndexer3.types create mode 100644 tests/baselines/reference/parserSymbolIndexer4.symbols create mode 100644 tests/baselines/reference/parserSymbolIndexer4.types create mode 100644 tests/baselines/reference/parserSymbolIndexer5.symbols create mode 100644 tests/baselines/reference/parserSymbolIndexer5.types create mode 100644 tests/baselines/reference/parserTernaryAndCommaOperators1.symbols create mode 100644 tests/baselines/reference/parserTernaryAndCommaOperators1.types create mode 100644 tests/baselines/reference/parserThrowStatement1.d.symbols create mode 100644 tests/baselines/reference/parserThrowStatement1.d.types create mode 100644 tests/baselines/reference/parserTryStatement1.d.symbols create mode 100644 tests/baselines/reference/parserTryStatement1.d.types create mode 100644 tests/baselines/reference/parserTypeAssertionInObjectCreationExpression1.symbols create mode 100644 tests/baselines/reference/parserTypeAssertionInObjectCreationExpression1.types create mode 100644 tests/baselines/reference/parserTypeQuery1.symbols create mode 100644 tests/baselines/reference/parserTypeQuery1.types create mode 100644 tests/baselines/reference/parserTypeQuery2.symbols create mode 100644 tests/baselines/reference/parserTypeQuery2.types create mode 100644 tests/baselines/reference/parserTypeQuery3.symbols create mode 100644 tests/baselines/reference/parserTypeQuery3.types create mode 100644 tests/baselines/reference/parserTypeQuery4.symbols create mode 100644 tests/baselines/reference/parserTypeQuery4.types create mode 100644 tests/baselines/reference/parserTypeQuery5.symbols create mode 100644 tests/baselines/reference/parserTypeQuery5.types create mode 100644 tests/baselines/reference/parserTypeQuery6.symbols create mode 100644 tests/baselines/reference/parserTypeQuery6.types create mode 100644 tests/baselines/reference/parserTypeQuery7.symbols create mode 100644 tests/baselines/reference/parserTypeQuery7.types create mode 100644 tests/baselines/reference/parserTypeQuery8.symbols create mode 100644 tests/baselines/reference/parserTypeQuery8.types create mode 100644 tests/baselines/reference/parserTypeQuery9.symbols create mode 100644 tests/baselines/reference/parserTypeQuery9.types create mode 100644 tests/baselines/reference/parserUnaryExpression1.symbols create mode 100644 tests/baselines/reference/parserUnaryExpression1.types create mode 100644 tests/baselines/reference/parserUnaryExpression2.symbols create mode 100644 tests/baselines/reference/parserUnaryExpression2.types create mode 100644 tests/baselines/reference/parserUnaryExpression3.symbols create mode 100644 tests/baselines/reference/parserUnaryExpression3.types create mode 100644 tests/baselines/reference/parserUnaryExpression4.symbols create mode 100644 tests/baselines/reference/parserUnaryExpression4.types create mode 100644 tests/baselines/reference/parserUnaryExpression5.symbols create mode 100644 tests/baselines/reference/parserUnaryExpression5.types create mode 100644 tests/baselines/reference/parserUnaryExpression7.symbols create mode 100644 tests/baselines/reference/parserUnaryExpression7.types create mode 100644 tests/baselines/reference/parserUnfinishedTypeNameBeforeKeyword1.symbols create mode 100644 tests/baselines/reference/parserUnfinishedTypeNameBeforeKeyword1.types create mode 100644 tests/baselines/reference/parserUnicode1.symbols create mode 100644 tests/baselines/reference/parserUnicode1.types create mode 100644 tests/baselines/reference/parserUnterminatedGeneric1.symbols create mode 100644 tests/baselines/reference/parserUnterminatedGeneric1.types create mode 100644 tests/baselines/reference/parserUnterminatedGeneric2.symbols create mode 100644 tests/baselines/reference/parserUnterminatedGeneric2.types create mode 100644 tests/baselines/reference/parserUsingConstructorAsIdentifier.symbols create mode 100644 tests/baselines/reference/parserUsingConstructorAsIdentifier.types create mode 100644 tests/baselines/reference/parserVariableDeclaration1.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration1.types create mode 100644 tests/baselines/reference/parserVariableDeclaration10.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration10.types create mode 100644 tests/baselines/reference/parserVariableDeclaration2.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration2.types create mode 100644 tests/baselines/reference/parserVariableDeclaration3.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration3.types create mode 100644 tests/baselines/reference/parserVariableDeclaration4.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration4.types create mode 100644 tests/baselines/reference/parserVariableDeclaration5.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration5.types create mode 100644 tests/baselines/reference/parserVariableDeclaration6.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration6.types create mode 100644 tests/baselines/reference/parserVariableDeclaration8.symbols create mode 100644 tests/baselines/reference/parserVariableDeclaration8.types create mode 100644 tests/baselines/reference/parserVariableStatement1.d.symbols create mode 100644 tests/baselines/reference/parserVariableStatement1.d.types create mode 100644 tests/baselines/reference/parserVariableStatement2.d.symbols create mode 100644 tests/baselines/reference/parserVariableStatement2.d.types create mode 100644 tests/baselines/reference/parserWhileStatement1.d.symbols create mode 100644 tests/baselines/reference/parserWhileStatement1.d.types create mode 100644 tests/baselines/reference/parserWithStatement1.d.symbols create mode 100644 tests/baselines/reference/parserWithStatement1.d.types create mode 100644 tests/baselines/reference/parserWithStatement2.symbols create mode 100644 tests/baselines/reference/parserWithStatement2.types create mode 100644 tests/baselines/reference/parserX_ArrowFunction1.symbols create mode 100644 tests/baselines/reference/parserX_ArrowFunction1.types create mode 100644 tests/baselines/reference/parserX_ArrowFunction3.symbols create mode 100644 tests/baselines/reference/parserX_ArrowFunction3.types create mode 100644 tests/baselines/reference/parserX_TypeArgumentList1.symbols create mode 100644 tests/baselines/reference/parserX_TypeArgumentList1.types create mode 100644 tests/baselines/reference/parser_breakInIterationOrSwitchStatement4.symbols create mode 100644 tests/baselines/reference/parser_breakInIterationOrSwitchStatement4.types create mode 100644 tests/baselines/reference/parser_breakNotInIterationOrSwitchStatement1.symbols create mode 100644 tests/baselines/reference/parser_breakNotInIterationOrSwitchStatement1.types create mode 100644 tests/baselines/reference/parser_breakNotInIterationOrSwitchStatement2.symbols create mode 100644 tests/baselines/reference/parser_breakNotInIterationOrSwitchStatement2.types create mode 100644 tests/baselines/reference/parser_breakTarget5.symbols create mode 100644 tests/baselines/reference/parser_breakTarget5.types create mode 100644 tests/baselines/reference/parser_breakTarget6.symbols create mode 100644 tests/baselines/reference/parser_breakTarget6.types create mode 100644 tests/baselines/reference/parser_continueInIterationStatement4.symbols create mode 100644 tests/baselines/reference/parser_continueInIterationStatement4.types create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement1.symbols create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement1.types create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement2.symbols create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement2.types create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement3.symbols create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement3.types create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement4.symbols create mode 100644 tests/baselines/reference/parser_continueNotInIterationStatement4.types create mode 100644 tests/baselines/reference/parser_continueTarget1.symbols create mode 100644 tests/baselines/reference/parser_continueTarget1.types create mode 100644 tests/baselines/reference/parser_continueTarget5.symbols create mode 100644 tests/baselines/reference/parser_continueTarget5.types create mode 100644 tests/baselines/reference/parser_continueTarget6.symbols create mode 100644 tests/baselines/reference/parser_continueTarget6.types create mode 100644 tests/baselines/reference/parser_duplicateLabel1.symbols create mode 100644 tests/baselines/reference/parser_duplicateLabel1.types create mode 100644 tests/baselines/reference/parser_duplicateLabel2.symbols create mode 100644 tests/baselines/reference/parser_duplicateLabel2.types create mode 100644 tests/baselines/reference/parserharness.symbols create mode 100644 tests/baselines/reference/parserharness.types create mode 100644 tests/baselines/reference/parserindenter.symbols create mode 100644 tests/baselines/reference/parserindenter.types create mode 100644 tests/baselines/reference/parservoidInQualifiedName1.symbols create mode 100644 tests/baselines/reference/parservoidInQualifiedName1.types create mode 100644 tests/baselines/reference/parservoidInQualifiedName2.symbols create mode 100644 tests/baselines/reference/parservoidInQualifiedName2.types create mode 100644 tests/baselines/reference/partiallyAnnotatedFunctionInferenceError.symbols create mode 100644 tests/baselines/reference/partiallyAnnotatedFunctionInferenceError.types create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution1_classic.symbols create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution1_classic.types create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution1_node.symbols create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution1_node.types create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution2_classic.symbols create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution2_classic.types create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution2_node.symbols create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution2_node.types create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.symbols create mode 100644 tests/baselines/reference/pathMappingBasedModuleResolution_withExtension_failedLookup.types create mode 100644 tests/baselines/reference/pathsValidation1.symbols create mode 100644 tests/baselines/reference/pathsValidation1.types create mode 100644 tests/baselines/reference/pathsValidation2.symbols create mode 100644 tests/baselines/reference/pathsValidation2.types create mode 100644 tests/baselines/reference/pathsValidation3.symbols create mode 100644 tests/baselines/reference/pathsValidation3.types create mode 100644 tests/baselines/reference/plusOperatorInvalidOperations.symbols create mode 100644 tests/baselines/reference/plusOperatorInvalidOperations.types create mode 100644 tests/baselines/reference/plusOperatorWithAnyOtherType.symbols create mode 100644 tests/baselines/reference/plusOperatorWithAnyOtherType.types create mode 100644 tests/baselines/reference/prettyContextNotDebugAssertion.symbols create mode 100644 tests/baselines/reference/prettyContextNotDebugAssertion.types create mode 100644 tests/baselines/reference/primaryExpressionMods.symbols create mode 100644 tests/baselines/reference/primaryExpressionMods.types create mode 100644 tests/baselines/reference/primitiveConstraints1.symbols create mode 100644 tests/baselines/reference/primitiveConstraints1.types create mode 100644 tests/baselines/reference/primitiveConstraints2.symbols create mode 100644 tests/baselines/reference/primitiveConstraints2.types create mode 100644 tests/baselines/reference/primitiveMembers.symbols create mode 100644 tests/baselines/reference/primitiveMembers.types create mode 100644 tests/baselines/reference/primitiveTypeAsClassName.symbols create mode 100644 tests/baselines/reference/primitiveTypeAsClassName.types create mode 100644 tests/baselines/reference/primitiveTypeAsInterfaceName.symbols create mode 100644 tests/baselines/reference/primitiveTypeAsInterfaceName.types create mode 100644 tests/baselines/reference/primitiveTypeAsInterfaceNameGeneric.symbols create mode 100644 tests/baselines/reference/primitiveTypeAsInterfaceNameGeneric.types create mode 100644 tests/baselines/reference/primitiveTypeAssignment.symbols create mode 100644 tests/baselines/reference/primitiveTypeAssignment.types create mode 100644 tests/baselines/reference/privacyAccessorDeclFile.symbols create mode 100644 tests/baselines/reference/privacyAccessorDeclFile.types create mode 100644 tests/baselines/reference/privacyCannotNameAccessorDeclFile.symbols create mode 100644 tests/baselines/reference/privacyCannotNameAccessorDeclFile.types create mode 100644 tests/baselines/reference/privacyCannotNameVarTypeDeclFile.symbols create mode 100644 tests/baselines/reference/privacyCannotNameVarTypeDeclFile.types create mode 100644 tests/baselines/reference/privacyCheckTypeOfFunction.symbols create mode 100644 tests/baselines/reference/privacyCheckTypeOfFunction.types create mode 100644 tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.symbols create mode 100644 tests/baselines/reference/privacyCheckTypeOfInvisibleModuleError.types create mode 100644 tests/baselines/reference/privacyCheckTypeOfInvisibleModuleNoError.symbols create mode 100644 tests/baselines/reference/privacyCheckTypeOfInvisibleModuleNoError.types create mode 100644 tests/baselines/reference/privacyClassExtendsClauseDeclFile.symbols create mode 100644 tests/baselines/reference/privacyClassExtendsClauseDeclFile.types create mode 100644 tests/baselines/reference/privacyClassImplementsClauseDeclFile.symbols create mode 100644 tests/baselines/reference/privacyClassImplementsClauseDeclFile.types create mode 100644 tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.symbols create mode 100644 tests/baselines/reference/privacyFunctionCannotNameParameterTypeDeclFile.types create mode 100644 tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.symbols create mode 100644 tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.types create mode 100644 tests/baselines/reference/privacyFunctionParameterDeclFile.symbols create mode 100644 tests/baselines/reference/privacyFunctionParameterDeclFile.types create mode 100644 tests/baselines/reference/privacyFunctionReturnTypeDeclFile.symbols create mode 100644 tests/baselines/reference/privacyFunctionReturnTypeDeclFile.types create mode 100644 tests/baselines/reference/privacyGloImport.symbols create mode 100644 tests/baselines/reference/privacyGloImport.types create mode 100644 tests/baselines/reference/privacyGloImportParseErrors.symbols create mode 100644 tests/baselines/reference/privacyGloImportParseErrors.types create mode 100644 tests/baselines/reference/privacyImport.symbols create mode 100644 tests/baselines/reference/privacyImport.types create mode 100644 tests/baselines/reference/privacyImportParseErrors.symbols create mode 100644 tests/baselines/reference/privacyImportParseErrors.types create mode 100644 tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.symbols create mode 100644 tests/baselines/reference/privacyInterfaceExtendsClauseDeclFile.types create mode 100644 tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.symbols create mode 100644 tests/baselines/reference/privacyLocalInternalReferenceImportWithExport.types create mode 100644 tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.symbols create mode 100644 tests/baselines/reference/privacyLocalInternalReferenceImportWithoutExport.types create mode 100644 tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithExport.symbols create mode 100644 tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithExport.types create mode 100644 tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.symbols create mode 100644 tests/baselines/reference/privacyTopLevelAmbientExternalModuleImportWithoutExport.types create mode 100644 tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.symbols create mode 100644 tests/baselines/reference/privacyTopLevelInternalReferenceImportWithExport.types create mode 100644 tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.symbols create mode 100644 tests/baselines/reference/privacyTopLevelInternalReferenceImportWithoutExport.types create mode 100644 tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.symbols create mode 100644 tests/baselines/reference/privacyTypeParameterOfFunctionDeclFile.types create mode 100644 tests/baselines/reference/privacyTypeParametersOfClassDeclFile.symbols create mode 100644 tests/baselines/reference/privacyTypeParametersOfClassDeclFile.types create mode 100644 tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.symbols create mode 100644 tests/baselines/reference/privacyTypeParametersOfInterfaceDeclFile.types create mode 100644 tests/baselines/reference/privacyVarDeclFile.symbols create mode 100644 tests/baselines/reference/privacyVarDeclFile.types create mode 100644 tests/baselines/reference/privateAccessInSubclass1.symbols create mode 100644 tests/baselines/reference/privateAccessInSubclass1.types create mode 100644 tests/baselines/reference/privateClassPropertyAccessibleWithinClass.symbols create mode 100644 tests/baselines/reference/privateClassPropertyAccessibleWithinClass.types create mode 100644 tests/baselines/reference/privateIndexer.symbols create mode 100644 tests/baselines/reference/privateIndexer.types create mode 100644 tests/baselines/reference/privateIndexer2.symbols create mode 100644 tests/baselines/reference/privateIndexer2.types create mode 100644 tests/baselines/reference/privateInstanceMemberAccessibility.symbols create mode 100644 tests/baselines/reference/privateInstanceMemberAccessibility.types create mode 100644 tests/baselines/reference/privateInterfaceProperties.symbols create mode 100644 tests/baselines/reference/privateInterfaceProperties.types create mode 100644 tests/baselines/reference/privateProtectedMembersAreNotAccessibleDestructuring.symbols create mode 100644 tests/baselines/reference/privateProtectedMembersAreNotAccessibleDestructuring.types create mode 100644 tests/baselines/reference/privateStaticMemberAccessibility.symbols create mode 100644 tests/baselines/reference/privateStaticMemberAccessibility.types create mode 100644 tests/baselines/reference/privateStaticNotAccessibleInClodule.symbols create mode 100644 tests/baselines/reference/privateStaticNotAccessibleInClodule.types create mode 100644 tests/baselines/reference/privateStaticNotAccessibleInClodule2.symbols create mode 100644 tests/baselines/reference/privateStaticNotAccessibleInClodule2.types create mode 100644 tests/baselines/reference/privateVisibility.symbols create mode 100644 tests/baselines/reference/privateVisibility.types create mode 100644 tests/baselines/reference/promiseChaining1.symbols create mode 100644 tests/baselines/reference/promiseChaining1.types create mode 100644 tests/baselines/reference/promiseChaining2.symbols create mode 100644 tests/baselines/reference/promiseChaining2.types create mode 100644 tests/baselines/reference/promiseEmptyTupleNoException.symbols create mode 100644 tests/baselines/reference/promiseEmptyTupleNoException.types create mode 100644 tests/baselines/reference/promiseIdentity2.symbols create mode 100644 tests/baselines/reference/promiseIdentity2.types create mode 100644 tests/baselines/reference/promiseIdentityWithAny2.symbols create mode 100644 tests/baselines/reference/promiseIdentityWithAny2.types create mode 100644 tests/baselines/reference/promisePermutations.symbols create mode 100644 tests/baselines/reference/promisePermutations.types create mode 100644 tests/baselines/reference/promisePermutations2.symbols create mode 100644 tests/baselines/reference/promisePermutations2.types create mode 100644 tests/baselines/reference/promisePermutations3.symbols create mode 100644 tests/baselines/reference/promisePermutations3.types create mode 100644 tests/baselines/reference/propertiesAndIndexers.symbols create mode 100644 tests/baselines/reference/propertiesAndIndexers.types create mode 100644 tests/baselines/reference/propertiesAndIndexers2.symbols create mode 100644 tests/baselines/reference/propertiesAndIndexers2.types create mode 100644 tests/baselines/reference/propertiesAndIndexersForNumericNames.symbols create mode 100644 tests/baselines/reference/propertiesAndIndexersForNumericNames.types create mode 100644 tests/baselines/reference/propertyAccess.symbols create mode 100644 tests/baselines/reference/propertyAccess.types create mode 100644 tests/baselines/reference/propertyAccess1.symbols create mode 100644 tests/baselines/reference/propertyAccess1.types create mode 100644 tests/baselines/reference/propertyAccess2.symbols create mode 100644 tests/baselines/reference/propertyAccess2.types create mode 100644 tests/baselines/reference/propertyAccess3.symbols create mode 100644 tests/baselines/reference/propertyAccess3.types create mode 100644 tests/baselines/reference/propertyAccess4.symbols create mode 100644 tests/baselines/reference/propertyAccess4.types create mode 100644 tests/baselines/reference/propertyAccess5.symbols create mode 100644 tests/baselines/reference/propertyAccess5.types create mode 100644 tests/baselines/reference/propertyAccessOfReadonlyIndexSignature.symbols create mode 100644 tests/baselines/reference/propertyAccessOfReadonlyIndexSignature.types create mode 100644 tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints4.symbols create mode 100644 tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints4.types create mode 100644 tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints5.symbols create mode 100644 tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints5.types create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignature.symbols create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignature.types create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.symbols create mode 100644 tests/baselines/reference/propertyAccessStringIndexSignatureNoImplicitAny.types create mode 100644 tests/baselines/reference/propertyAccessibility1.symbols create mode 100644 tests/baselines/reference/propertyAccessibility1.types create mode 100644 tests/baselines/reference/propertyAccessibility2.symbols create mode 100644 tests/baselines/reference/propertyAccessibility2.types create mode 100644 tests/baselines/reference/propertyAndAccessorWithSameName.symbols create mode 100644 tests/baselines/reference/propertyAndAccessorWithSameName.types create mode 100644 tests/baselines/reference/propertyAndFunctionWithSameName.symbols create mode 100644 tests/baselines/reference/propertyAndFunctionWithSameName.types create mode 100644 tests/baselines/reference/propertyAssignment.symbols create mode 100644 tests/baselines/reference/propertyAssignment.types create mode 100644 tests/baselines/reference/propertyIdentityWithPrivacyMismatch.symbols create mode 100644 tests/baselines/reference/propertyIdentityWithPrivacyMismatch.types create mode 100644 tests/baselines/reference/propertyOrdering.symbols create mode 100644 tests/baselines/reference/propertyOrdering.types create mode 100644 tests/baselines/reference/propertyOrdering2.symbols create mode 100644 tests/baselines/reference/propertyOrdering2.types create mode 100644 tests/baselines/reference/propertyParameterWithQuestionMark.symbols create mode 100644 tests/baselines/reference/propertyParameterWithQuestionMark.types create mode 100644 tests/baselines/reference/propertySignatures.symbols create mode 100644 tests/baselines/reference/propertySignatures.types create mode 100644 tests/baselines/reference/propertyWrappedInTry.symbols create mode 100644 tests/baselines/reference/propertyWrappedInTry.types create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.symbols create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass.types create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass1.symbols create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinNestedSubclass1.types create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass2.symbols create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass2.types create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass3.symbols create mode 100644 tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass3.types create mode 100644 tests/baselines/reference/protectedInstanceMemberAccessibility.symbols create mode 100644 tests/baselines/reference/protectedInstanceMemberAccessibility.types create mode 100644 tests/baselines/reference/protectedMembers.symbols create mode 100644 tests/baselines/reference/protectedMembers.types create mode 100644 tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass.symbols create mode 100644 tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass.types create mode 100644 tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass2.symbols create mode 100644 tests/baselines/reference/protectedStaticClassPropertyAccessibleWithinSubclass2.types create mode 100644 tests/baselines/reference/protectedStaticNotAccessibleInClodule.symbols create mode 100644 tests/baselines/reference/protectedStaticNotAccessibleInClodule.types create mode 100644 tests/baselines/reference/protoAssignment.symbols create mode 100644 tests/baselines/reference/protoAssignment.types create mode 100644 tests/baselines/reference/prototypes.symbols create mode 100644 tests/baselines/reference/prototypes.types create mode 100644 tests/baselines/reference/publicIndexer.symbols create mode 100644 tests/baselines/reference/publicIndexer.types create mode 100644 tests/baselines/reference/publicMemberImplementedAsPrivateInDerivedClass.symbols create mode 100644 tests/baselines/reference/publicMemberImplementedAsPrivateInDerivedClass.types create mode 100644 tests/baselines/reference/qualifiedModuleLocals.symbols create mode 100644 tests/baselines/reference/qualifiedModuleLocals.types create mode 100644 tests/baselines/reference/qualifiedName_entity-name-resolution-does-not-affect-class-heritage.symbols create mode 100644 tests/baselines/reference/qualifiedName_entity-name-resolution-does-not-affect-class-heritage.types create mode 100644 tests/baselines/reference/qualify.symbols create mode 100644 tests/baselines/reference/qualify.types create mode 100644 tests/baselines/reference/quotedAccessorName1.symbols create mode 100644 tests/baselines/reference/quotedAccessorName1.types create mode 100644 tests/baselines/reference/quotedAccessorName2.symbols create mode 100644 tests/baselines/reference/quotedAccessorName2.types create mode 100644 tests/baselines/reference/quotedModuleNameMustBeAmbient.symbols create mode 100644 tests/baselines/reference/quotedModuleNameMustBeAmbient.types create mode 100644 tests/baselines/reference/raiseErrorOnParameterProperty.symbols create mode 100644 tests/baselines/reference/raiseErrorOnParameterProperty.types create mode 100644 tests/baselines/reference/reExportGlobalDeclaration1.symbols create mode 100644 tests/baselines/reference/reExportGlobalDeclaration1.types create mode 100644 tests/baselines/reference/reExportGlobalDeclaration2.symbols create mode 100644 tests/baselines/reference/reExportGlobalDeclaration2.types create mode 100644 tests/baselines/reference/reExportGlobalDeclaration3.symbols create mode 100644 tests/baselines/reference/reExportGlobalDeclaration3.types create mode 100644 tests/baselines/reference/reExportGlobalDeclaration4.symbols create mode 100644 tests/baselines/reference/reExportGlobalDeclaration4.types create mode 100644 tests/baselines/reference/reExportUndefined1.symbols create mode 100644 tests/baselines/reference/reExportUndefined1.types create mode 100644 tests/baselines/reference/reachabilityChecks1.symbols create mode 100644 tests/baselines/reference/reachabilityChecks1.types create mode 100644 tests/baselines/reference/reachabilityChecks2.symbols create mode 100644 tests/baselines/reference/reachabilityChecks2.types create mode 100644 tests/baselines/reference/reachabilityChecks3.symbols create mode 100644 tests/baselines/reference/reachabilityChecks3.types create mode 100644 tests/baselines/reference/reachabilityChecks4.symbols create mode 100644 tests/baselines/reference/reachabilityChecks4.types create mode 100644 tests/baselines/reference/reachabilityChecks5.symbols create mode 100644 tests/baselines/reference/reachabilityChecks5.types create mode 100644 tests/baselines/reference/reachabilityChecks6.symbols create mode 100644 tests/baselines/reference/reachabilityChecks6.types create mode 100644 tests/baselines/reference/reachabilityChecks7.symbols create mode 100644 tests/baselines/reference/reachabilityChecks7.types create mode 100644 tests/baselines/reference/reactNamespaceInvalidInput.symbols create mode 100644 tests/baselines/reference/reactNamespaceInvalidInput.types create mode 100644 tests/baselines/reference/reactNamespaceMissingDeclaration.symbols create mode 100644 tests/baselines/reference/reactNamespaceMissingDeclaration.types create mode 100644 tests/baselines/reference/readonlyConstructorAssignment.symbols create mode 100644 tests/baselines/reference/readonlyConstructorAssignment.types create mode 100644 tests/baselines/reference/readonlyInAmbientClass.symbols create mode 100644 tests/baselines/reference/readonlyInAmbientClass.types create mode 100644 tests/baselines/reference/readonlyInConstructorParameters.symbols create mode 100644 tests/baselines/reference/readonlyInConstructorParameters.types create mode 100644 tests/baselines/reference/readonlyInNonPropertyParameters.symbols create mode 100644 tests/baselines/reference/readonlyInNonPropertyParameters.types create mode 100644 tests/baselines/reference/readonlyMembers.symbols create mode 100644 tests/baselines/reference/readonlyMembers.types create mode 100644 tests/baselines/reference/readonlyReadonly.symbols create mode 100644 tests/baselines/reference/readonlyReadonly.types create mode 100644 tests/baselines/reference/reassignStaticProp.symbols create mode 100644 tests/baselines/reference/reassignStaticProp.types create mode 100644 tests/baselines/reference/reboundIdentifierOnImportAlias.symbols create mode 100644 tests/baselines/reference/reboundIdentifierOnImportAlias.types create mode 100644 tests/baselines/reference/recursiveBaseCheck.symbols create mode 100644 tests/baselines/reference/recursiveBaseCheck.types create mode 100644 tests/baselines/reference/recursiveBaseCheck2.symbols create mode 100644 tests/baselines/reference/recursiveBaseCheck2.types create mode 100644 tests/baselines/reference/recursiveBaseCheck3.symbols create mode 100644 tests/baselines/reference/recursiveBaseCheck3.types create mode 100644 tests/baselines/reference/recursiveBaseCheck4.symbols create mode 100644 tests/baselines/reference/recursiveBaseCheck4.types create mode 100644 tests/baselines/reference/recursiveBaseCheck5.symbols create mode 100644 tests/baselines/reference/recursiveBaseCheck5.types create mode 100644 tests/baselines/reference/recursiveBaseCheck6.symbols create mode 100644 tests/baselines/reference/recursiveBaseCheck6.types create mode 100644 tests/baselines/reference/recursiveBaseConstructorCreation3.symbols create mode 100644 tests/baselines/reference/recursiveBaseConstructorCreation3.types create mode 100644 tests/baselines/reference/recursiveClassReferenceTest.symbols create mode 100644 tests/baselines/reference/recursiveClassReferenceTest.types create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType1.symbols create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType1.types create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType2.symbols create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType2.types create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType3.symbols create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType3.types create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType4.symbols create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType4.types create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType5.symbols create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType5.types create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType6.symbols create mode 100644 tests/baselines/reference/recursiveExportAssignmentAndFindAliasedType6.types create mode 100644 tests/baselines/reference/recursiveFunctionTypes.symbols create mode 100644 tests/baselines/reference/recursiveFunctionTypes.types create mode 100644 tests/baselines/reference/recursiveGetterAccess.symbols create mode 100644 tests/baselines/reference/recursiveGetterAccess.types create mode 100644 tests/baselines/reference/recursiveInferenceBug.symbols create mode 100644 tests/baselines/reference/recursiveInferenceBug.types create mode 100644 tests/baselines/reference/recursiveInheritance.symbols create mode 100644 tests/baselines/reference/recursiveInheritance.types create mode 100644 tests/baselines/reference/recursiveInheritance3.symbols create mode 100644 tests/baselines/reference/recursiveInheritance3.types create mode 100644 tests/baselines/reference/recursiveInheritanceGeneric.symbols create mode 100644 tests/baselines/reference/recursiveInheritanceGeneric.types create mode 100644 tests/baselines/reference/recursiveIntersectionTypes.symbols create mode 100644 tests/baselines/reference/recursiveIntersectionTypes.types create mode 100644 tests/baselines/reference/recursiveLetConst.symbols create mode 100644 tests/baselines/reference/recursiveLetConst.types create mode 100644 tests/baselines/reference/recursiveNamedLambdaCall.symbols create mode 100644 tests/baselines/reference/recursiveNamedLambdaCall.types create mode 100644 tests/baselines/reference/recursiveSpecializationOfSignatures.symbols create mode 100644 tests/baselines/reference/recursiveSpecializationOfSignatures.types create mode 100644 tests/baselines/reference/recursiveTypeComparison2.symbols create mode 100644 tests/baselines/reference/recursiveTypeComparison2.types create mode 100644 tests/baselines/reference/recursiveTypeParameterConstraintReferenceLacksTypeArgs.symbols create mode 100644 tests/baselines/reference/recursiveTypeParameterConstraintReferenceLacksTypeArgs.types create mode 100644 tests/baselines/reference/recursiveTypeRelations.symbols create mode 100644 tests/baselines/reference/recursiveTypeRelations.types create mode 100644 tests/baselines/reference/recursiveTypesWithTypeof.symbols create mode 100644 tests/baselines/reference/recursiveTypesWithTypeof.types create mode 100644 tests/baselines/reference/redeclareParameterInCatchBlock.symbols create mode 100644 tests/baselines/reference/redeclareParameterInCatchBlock.types create mode 100644 tests/baselines/reference/redefineArray.symbols create mode 100644 tests/baselines/reference/redefineArray.types create mode 100644 tests/baselines/reference/reexportedMissingAlias.symbols create mode 100644 tests/baselines/reference/reexportedMissingAlias.types create mode 100644 tests/baselines/reference/relationalOperatorComparable.symbols create mode 100644 tests/baselines/reference/relationalOperatorComparable.types create mode 100644 tests/baselines/reference/relativeNamesInClassicResolution.symbols create mode 100644 tests/baselines/reference/relativeNamesInClassicResolution.types create mode 100644 tests/baselines/reference/relativePathMustResolve.symbols create mode 100644 tests/baselines/reference/relativePathMustResolve.types create mode 100644 tests/baselines/reference/requireOfAnEmptyFile1.symbols create mode 100644 tests/baselines/reference/requireOfAnEmptyFile1.types create mode 100644 tests/baselines/reference/requiredInitializedParameter1.symbols create mode 100644 tests/baselines/reference/requiredInitializedParameter1.types create mode 100644 tests/baselines/reference/requiredInitializedParameter2.symbols create mode 100644 tests/baselines/reference/requiredInitializedParameter2.types create mode 100644 tests/baselines/reference/reservedNameOnInterfaceImport.symbols create mode 100644 tests/baselines/reference/reservedNameOnInterfaceImport.types create mode 100644 tests/baselines/reference/reservedNameOnModuleImportWithInterface.symbols create mode 100644 tests/baselines/reference/reservedNameOnModuleImportWithInterface.types create mode 100644 tests/baselines/reference/reservedNamesInAliases.symbols create mode 100644 tests/baselines/reference/reservedNamesInAliases.types create mode 100644 tests/baselines/reference/reservedWords2.symbols create mode 100644 tests/baselines/reference/reservedWords2.types create mode 100644 tests/baselines/reference/resolvingClassDeclarationWhenInBaseTypeResolution.symbols create mode 100644 tests/baselines/reference/resolvingClassDeclarationWhenInBaseTypeResolution.types create mode 100644 tests/baselines/reference/restArgAssignmentCompat.symbols create mode 100644 tests/baselines/reference/restArgAssignmentCompat.types create mode 100644 tests/baselines/reference/restArgMissingName.symbols create mode 100644 tests/baselines/reference/restArgMissingName.types create mode 100644 tests/baselines/reference/restElementMustBeLast.symbols create mode 100644 tests/baselines/reference/restElementMustBeLast.types create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern1.symbols create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern1.types create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern2.symbols create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern2.types create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern3.symbols create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern3.types create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern4.symbols create mode 100644 tests/baselines/reference/restElementWithAssignmentPattern4.types create mode 100644 tests/baselines/reference/restElementWithBindingPattern.symbols create mode 100644 tests/baselines/reference/restElementWithBindingPattern.types create mode 100644 tests/baselines/reference/restElementWithBindingPattern2.symbols create mode 100644 tests/baselines/reference/restElementWithBindingPattern2.types create mode 100644 tests/baselines/reference/restElementWithInitializer1.symbols create mode 100644 tests/baselines/reference/restElementWithInitializer1.types create mode 100644 tests/baselines/reference/restElementWithInitializer2.symbols create mode 100644 tests/baselines/reference/restElementWithInitializer2.types create mode 100644 tests/baselines/reference/restElementWithNullInitializer.symbols create mode 100644 tests/baselines/reference/restElementWithNullInitializer.types create mode 100644 tests/baselines/reference/restInvalidArgumentType.symbols create mode 100644 tests/baselines/reference/restInvalidArgumentType.types create mode 100644 tests/baselines/reference/restParamAsOptional.symbols create mode 100644 tests/baselines/reference/restParamAsOptional.types create mode 100644 tests/baselines/reference/restParamModifier.symbols create mode 100644 tests/baselines/reference/restParamModifier.types create mode 100644 tests/baselines/reference/restParamModifier2.symbols create mode 100644 tests/baselines/reference/restParamModifier2.types create mode 100644 tests/baselines/reference/restParameterNotLast.symbols create mode 100644 tests/baselines/reference/restParameterNotLast.types create mode 100644 tests/baselines/reference/restParameterWithBindingPattern1.symbols create mode 100644 tests/baselines/reference/restParameterWithBindingPattern1.types create mode 100644 tests/baselines/reference/restParameterWithBindingPattern2.symbols create mode 100644 tests/baselines/reference/restParameterWithBindingPattern2.types create mode 100644 tests/baselines/reference/restParameterWithoutAnnotationIsAnyArray.symbols create mode 100644 tests/baselines/reference/restParameterWithoutAnnotationIsAnyArray.types create mode 100644 tests/baselines/reference/restParametersOfNonArrayTypes.symbols create mode 100644 tests/baselines/reference/restParametersOfNonArrayTypes.types create mode 100644 tests/baselines/reference/restParametersOfNonArrayTypes2.symbols create mode 100644 tests/baselines/reference/restParametersOfNonArrayTypes2.types create mode 100644 tests/baselines/reference/restParametersWithArrayTypeAnnotations.symbols create mode 100644 tests/baselines/reference/restParametersWithArrayTypeAnnotations.types create mode 100644 tests/baselines/reference/restParamsWithNonRestParams.symbols create mode 100644 tests/baselines/reference/restParamsWithNonRestParams.types create mode 100644 tests/baselines/reference/restUnion3.symbols create mode 100644 tests/baselines/reference/restUnion3.types create mode 100644 tests/baselines/reference/returnInConstructor1.symbols create mode 100644 tests/baselines/reference/returnInConstructor1.types create mode 100644 tests/baselines/reference/returnTypeParameter.symbols create mode 100644 tests/baselines/reference/returnTypeParameter.types create mode 100644 tests/baselines/reference/returnTypeTypeArguments.symbols create mode 100644 tests/baselines/reference/returnTypeTypeArguments.types create mode 100644 tests/baselines/reference/returnValueInSetter.symbols create mode 100644 tests/baselines/reference/returnValueInSetter.types create mode 100644 tests/baselines/reference/scanner10.1.1-8gs.symbols create mode 100644 tests/baselines/reference/scanner10.1.1-8gs.types create mode 100644 tests/baselines/reference/scannerAdditiveExpression1.symbols create mode 100644 tests/baselines/reference/scannerAdditiveExpression1.types create mode 100644 tests/baselines/reference/scannerClass2.symbols create mode 100644 tests/baselines/reference/scannerClass2.types create mode 100644 tests/baselines/reference/scannerES3NumericLiteral3.symbols create mode 100644 tests/baselines/reference/scannerES3NumericLiteral3.types create mode 100644 tests/baselines/reference/scannerES3NumericLiteral4.symbols create mode 100644 tests/baselines/reference/scannerES3NumericLiteral4.types create mode 100644 tests/baselines/reference/scannerES3NumericLiteral6.symbols create mode 100644 tests/baselines/reference/scannerES3NumericLiteral6.types create mode 100644 tests/baselines/reference/scannerImportDeclaration1.symbols create mode 100644 tests/baselines/reference/scannerImportDeclaration1.types create mode 100644 tests/baselines/reference/scannerNumericLiteral2.symbols create mode 100644 tests/baselines/reference/scannerNumericLiteral2.types create mode 100644 tests/baselines/reference/scannerNumericLiteral3.symbols create mode 100644 tests/baselines/reference/scannerNumericLiteral3.types create mode 100644 tests/baselines/reference/scannerNumericLiteral4.symbols create mode 100644 tests/baselines/reference/scannerNumericLiteral4.types create mode 100644 tests/baselines/reference/scannerNumericLiteral6.symbols create mode 100644 tests/baselines/reference/scannerNumericLiteral6.types create mode 100644 tests/baselines/reference/scannerNumericLiteral8.symbols create mode 100644 tests/baselines/reference/scannerNumericLiteral8.types create mode 100644 tests/baselines/reference/scannerNumericLiteral9.symbols create mode 100644 tests/baselines/reference/scannerNumericLiteral9.types create mode 100644 tests/baselines/reference/scannerS7.2_A1.5_T2.symbols create mode 100644 tests/baselines/reference/scannerS7.2_A1.5_T2.types create mode 100644 tests/baselines/reference/scannerS7.3_A1.1_T2.symbols create mode 100644 tests/baselines/reference/scannerS7.3_A1.1_T2.types create mode 100644 tests/baselines/reference/scannerS7.4_A2_T2.symbols create mode 100644 tests/baselines/reference/scannerS7.4_A2_T2.types create mode 100644 tests/baselines/reference/scannerS7.6_A4.2_T1.symbols create mode 100644 tests/baselines/reference/scannerS7.6_A4.2_T1.types create mode 100644 tests/baselines/reference/scannerS7.8.3_A6.1_T1.symbols create mode 100644 tests/baselines/reference/scannerS7.8.3_A6.1_T1.types create mode 100644 tests/baselines/reference/scannerS7.8.4_A7.1_T4.symbols create mode 100644 tests/baselines/reference/scannerS7.8.4_A7.1_T4.types create mode 100644 tests/baselines/reference/scannerStringLiterals.symbols create mode 100644 tests/baselines/reference/scannerStringLiterals.types create mode 100644 tests/baselines/reference/scannerUnexpectedNullCharacter1.symbols create mode 100644 tests/baselines/reference/scannerUnexpectedNullCharacter1.types create mode 100644 tests/baselines/reference/scannertest1.symbols create mode 100644 tests/baselines/reference/scannertest1.types create mode 100644 tests/baselines/reference/scopeCheckExtendedClassInsidePublicMethod2.symbols create mode 100644 tests/baselines/reference/scopeCheckExtendedClassInsidePublicMethod2.types create mode 100644 tests/baselines/reference/scopeCheckExtendedClassInsideStaticMethod1.symbols create mode 100644 tests/baselines/reference/scopeCheckExtendedClassInsideStaticMethod1.types create mode 100644 tests/baselines/reference/scopeCheckInsidePublicMethod1.symbols create mode 100644 tests/baselines/reference/scopeCheckInsidePublicMethod1.types create mode 100644 tests/baselines/reference/scopeCheckInsideStaticMethod1.symbols create mode 100644 tests/baselines/reference/scopeCheckInsideStaticMethod1.types create mode 100644 tests/baselines/reference/scopeCheckStaticInitializer.symbols create mode 100644 tests/baselines/reference/scopeCheckStaticInitializer.types create mode 100644 tests/baselines/reference/scopeTests.symbols create mode 100644 tests/baselines/reference/scopeTests.types create mode 100644 tests/baselines/reference/scopingInCatchBlocks.symbols create mode 100644 tests/baselines/reference/scopingInCatchBlocks.types create mode 100644 tests/baselines/reference/selfRef.symbols create mode 100644 tests/baselines/reference/selfRef.types create mode 100644 tests/baselines/reference/selfReferencesInFunctionParameters.symbols create mode 100644 tests/baselines/reference/selfReferencesInFunctionParameters.types create mode 100644 tests/baselines/reference/selfReferencingFile.symbols create mode 100644 tests/baselines/reference/selfReferencingFile.types create mode 100644 tests/baselines/reference/selfReferencingFile2.symbols create mode 100644 tests/baselines/reference/selfReferencingFile2.types create mode 100644 tests/baselines/reference/selfReferencingFile3.symbols create mode 100644 tests/baselines/reference/selfReferencingFile3.types create mode 100644 tests/baselines/reference/selfReferencingSpreadInLoop.symbols create mode 100644 tests/baselines/reference/selfReferencingSpreadInLoop.types create mode 100644 tests/baselines/reference/semicolonsInModuleDeclarations.symbols create mode 100644 tests/baselines/reference/semicolonsInModuleDeclarations.types create mode 100644 tests/baselines/reference/separate1-1.symbols create mode 100644 tests/baselines/reference/separate1-1.types create mode 100644 tests/baselines/reference/setterBeforeGetter.symbols create mode 100644 tests/baselines/reference/setterBeforeGetter.types create mode 100644 tests/baselines/reference/setterWithReturn.symbols create mode 100644 tests/baselines/reference/setterWithReturn.types create mode 100644 tests/baselines/reference/shadowPrivateMembers.symbols create mode 100644 tests/baselines/reference/shadowPrivateMembers.types create mode 100644 tests/baselines/reference/shadowedInternalModule.symbols create mode 100644 tests/baselines/reference/shadowedInternalModule.types create mode 100644 tests/baselines/reference/shadowingViaLocalValue.symbols create mode 100644 tests/baselines/reference/shadowingViaLocalValue.types create mode 100644 tests/baselines/reference/shadowingViaLocalValueOrBindingElement.symbols create mode 100644 tests/baselines/reference/shadowingViaLocalValueOrBindingElement.types create mode 100644 tests/baselines/reference/shebangError.symbols create mode 100644 tests/baselines/reference/shebangError.types create mode 100644 tests/baselines/reference/shorthand-property-es5-es6.symbols create mode 100644 tests/baselines/reference/shorthand-property-es5-es6.types create mode 100644 tests/baselines/reference/shorthand-property-es6-amd.symbols create mode 100644 tests/baselines/reference/shorthand-property-es6-amd.types create mode 100644 tests/baselines/reference/shorthand-property-es6-es6.symbols create mode 100644 tests/baselines/reference/shorthand-property-es6-es6.types create mode 100644 tests/baselines/reference/shorthandPropertyAssignmentInES6Module.symbols create mode 100644 tests/baselines/reference/shorthandPropertyAssignmentInES6Module.types create mode 100644 tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.symbols create mode 100644 tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.types create mode 100644 tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.symbols create mode 100644 tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.types create mode 100644 tests/baselines/reference/slashBeforeVariableDeclaration1.symbols create mode 100644 tests/baselines/reference/slashBeforeVariableDeclaration1.types create mode 100644 tests/baselines/reference/sourceMapSample.symbols create mode 100644 tests/baselines/reference/sourceMapSample.types create mode 100644 tests/baselines/reference/sourceMapValidationEnums.symbols create mode 100644 tests/baselines/reference/sourceMapValidationEnums.types create mode 100644 tests/baselines/reference/sourceMapValidationFor.symbols create mode 100644 tests/baselines/reference/sourceMapValidationFor.types create mode 100644 tests/baselines/reference/sourceMapValidationForIn.symbols create mode 100644 tests/baselines/reference/sourceMapValidationForIn.types create mode 100644 tests/baselines/reference/sourceMapValidationStatements.symbols create mode 100644 tests/baselines/reference/sourceMapValidationStatements.types create mode 100644 tests/baselines/reference/spaceBeforeQuestionMarkInPropertyAssignment.symbols create mode 100644 tests/baselines/reference/spaceBeforeQuestionMarkInPropertyAssignment.types create mode 100644 tests/baselines/reference/specializedSignatureAsCallbackParameter1.symbols create mode 100644 tests/baselines/reference/specializedSignatureAsCallbackParameter1.types create mode 100644 tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.symbols create mode 100644 tests/baselines/reference/specializedSignatureIsNotSubtypeOfNonSpecializedSignature.types create mode 100644 tests/baselines/reference/spellingSuggestionLeadingUnderscores01.symbols create mode 100644 tests/baselines/reference/spellingSuggestionLeadingUnderscores01.types create mode 100644 tests/baselines/reference/spreadInvalidArgumentType.symbols create mode 100644 tests/baselines/reference/spreadInvalidArgumentType.types create mode 100644 tests/baselines/reference/spreadMethods.symbols create mode 100644 tests/baselines/reference/spreadMethods.types create mode 100644 tests/baselines/reference/spreadUnion3.symbols create mode 100644 tests/baselines/reference/spreadUnion3.types create mode 100644 tests/baselines/reference/standaloneBreak.symbols create mode 100644 tests/baselines/reference/standaloneBreak.types create mode 100644 tests/baselines/reference/staticAsIdentifier.symbols create mode 100644 tests/baselines/reference/staticAsIdentifier.types create mode 100644 tests/baselines/reference/staticClassMemberError.symbols create mode 100644 tests/baselines/reference/staticClassMemberError.types create mode 100644 tests/baselines/reference/staticClassProps.symbols create mode 100644 tests/baselines/reference/staticClassProps.types create mode 100644 tests/baselines/reference/staticGetter1.symbols create mode 100644 tests/baselines/reference/staticGetter1.types create mode 100644 tests/baselines/reference/staticGetterAndSetter.symbols create mode 100644 tests/baselines/reference/staticGetterAndSetter.types create mode 100644 tests/baselines/reference/staticIndexer.symbols create mode 100644 tests/baselines/reference/staticIndexer.types create mode 100644 tests/baselines/reference/staticIndexers.symbols create mode 100644 tests/baselines/reference/staticIndexers.types create mode 100644 tests/baselines/reference/staticInstanceResolution4.symbols create mode 100644 tests/baselines/reference/staticInstanceResolution4.types create mode 100644 tests/baselines/reference/staticInstanceResolution5.symbols create mode 100644 tests/baselines/reference/staticInstanceResolution5.types create mode 100644 tests/baselines/reference/staticMemberAssignsToConstructorFunctionMembers.symbols create mode 100644 tests/baselines/reference/staticMemberAssignsToConstructorFunctionMembers.types create mode 100644 tests/baselines/reference/staticMemberExportAccess.symbols create mode 100644 tests/baselines/reference/staticMemberExportAccess.types create mode 100644 tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.symbols create mode 100644 tests/baselines/reference/staticMemberOfClassAndPublicMemberOfAnotherClassAssignment.types create mode 100644 tests/baselines/reference/staticMembersUsingClassTypeParameter.symbols create mode 100644 tests/baselines/reference/staticMembersUsingClassTypeParameter.types create mode 100644 tests/baselines/reference/staticMethodReferencingTypeArgument1.symbols create mode 100644 tests/baselines/reference/staticMethodReferencingTypeArgument1.types create mode 100644 tests/baselines/reference/staticMethodsReferencingClassTypeParameters.symbols create mode 100644 tests/baselines/reference/staticMethodsReferencingClassTypeParameters.types create mode 100644 tests/baselines/reference/staticModifierAlreadySeen.symbols create mode 100644 tests/baselines/reference/staticModifierAlreadySeen.types create mode 100644 tests/baselines/reference/staticMustPrecedePublic.symbols create mode 100644 tests/baselines/reference/staticMustPrecedePublic.types create mode 100644 tests/baselines/reference/staticOffOfInstance1.symbols create mode 100644 tests/baselines/reference/staticOffOfInstance1.types create mode 100644 tests/baselines/reference/staticOffOfInstance2.symbols create mode 100644 tests/baselines/reference/staticOffOfInstance2.types create mode 100644 tests/baselines/reference/staticPropSuper.symbols create mode 100644 tests/baselines/reference/staticPropSuper.types create mode 100644 tests/baselines/reference/staticPropertyNameConflicts.symbols create mode 100644 tests/baselines/reference/staticPropertyNameConflicts.types create mode 100644 tests/baselines/reference/staticPropertyNotInClassType.symbols create mode 100644 tests/baselines/reference/staticPropertyNotInClassType.types create mode 100644 tests/baselines/reference/staticPrototypeProperty.symbols create mode 100644 tests/baselines/reference/staticPrototypeProperty.types create mode 100644 tests/baselines/reference/staticVisibility.symbols create mode 100644 tests/baselines/reference/staticVisibility.types create mode 100644 tests/baselines/reference/statics.symbols create mode 100644 tests/baselines/reference/statics.types create mode 100644 tests/baselines/reference/staticsInAFunction.symbols create mode 100644 tests/baselines/reference/staticsInAFunction.types create mode 100644 tests/baselines/reference/staticsInConstructorBodies.symbols create mode 100644 tests/baselines/reference/staticsInConstructorBodies.types create mode 100644 tests/baselines/reference/staticsNotInScopeInClodule.symbols create mode 100644 tests/baselines/reference/staticsNotInScopeInClodule.types create mode 100644 tests/baselines/reference/strictModeInConstructor.symbols create mode 100644 tests/baselines/reference/strictModeInConstructor.types create mode 100644 tests/baselines/reference/strictModeReservedWord.symbols create mode 100644 tests/baselines/reference/strictModeReservedWord.types create mode 100644 tests/baselines/reference/strictModeReservedWord2.symbols create mode 100644 tests/baselines/reference/strictModeReservedWord2.types create mode 100644 tests/baselines/reference/strictModeReservedWordInClassDeclaration.symbols create mode 100644 tests/baselines/reference/strictModeReservedWordInClassDeclaration.types create mode 100644 tests/baselines/reference/strictModeReservedWordInDestructuring.symbols create mode 100644 tests/baselines/reference/strictModeReservedWordInDestructuring.types create mode 100644 tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.symbols create mode 100644 tests/baselines/reference/strictModeReservedWordInImportEqualDeclaration.types create mode 100644 tests/baselines/reference/strictModeReservedWordInModuleDeclaration.symbols create mode 100644 tests/baselines/reference/strictModeReservedWordInModuleDeclaration.types create mode 100644 tests/baselines/reference/strictModeWordInImportDeclaration.symbols create mode 100644 tests/baselines/reference/strictModeWordInImportDeclaration.types create mode 100644 tests/baselines/reference/stringEnumLiteralTypes3.symbols create mode 100644 tests/baselines/reference/stringEnumLiteralTypes3.types create mode 100644 tests/baselines/reference/stringIndexerAndConstructor.symbols create mode 100644 tests/baselines/reference/stringIndexerAndConstructor.types create mode 100644 tests/baselines/reference/stringIndexerAndConstructor1.symbols create mode 100644 tests/baselines/reference/stringIndexerAndConstructor1.types create mode 100644 tests/baselines/reference/stringIndexerAssignments1.symbols create mode 100644 tests/baselines/reference/stringIndexerAssignments1.types create mode 100644 tests/baselines/reference/stringIndexerAssignments2.symbols create mode 100644 tests/baselines/reference/stringIndexerAssignments2.types create mode 100644 tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.symbols create mode 100644 tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.types create mode 100644 tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations2.symbols create mode 100644 tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations2.types create mode 100644 tests/baselines/reference/stringLiteralTypesInImplementationSignatures2.symbols create mode 100644 tests/baselines/reference/stringLiteralTypesInImplementationSignatures2.types create mode 100644 tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.symbols create mode 100644 tests/baselines/reference/stringLiteralTypesInVariableDeclarations01.types create mode 100644 tests/baselines/reference/stringLiteralTypesOverloadAssignability01.symbols create mode 100644 tests/baselines/reference/stringLiteralTypesOverloadAssignability01.types create mode 100644 tests/baselines/reference/stringLiteralTypesOverloadAssignability02.symbols create mode 100644 tests/baselines/reference/stringLiteralTypesOverloadAssignability02.types create mode 100644 tests/baselines/reference/stringLiteralTypesOverloads05.symbols create mode 100644 tests/baselines/reference/stringLiteralTypesOverloads05.types create mode 100644 tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.symbols create mode 100644 tests/baselines/reference/stringLiteralTypesWithTemplateStrings02.types create mode 100644 tests/baselines/reference/stringLiteralTypesWithVariousOperators02.symbols create mode 100644 tests/baselines/reference/stringLiteralTypesWithVariousOperators02.types create mode 100644 tests/baselines/reference/stringLiteralsAssertionsInEqualityComparisons02.symbols create mode 100644 tests/baselines/reference/stringLiteralsAssertionsInEqualityComparisons02.types create mode 100644 tests/baselines/reference/stringLiteralsErrors.symbols create mode 100644 tests/baselines/reference/stringLiteralsErrors.types create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks01.symbols create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks01.types create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks02.symbols create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks02.types create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks03.symbols create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks03.types create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks04.symbols create mode 100644 tests/baselines/reference/stringLiteralsWithEqualityChecks04.types create mode 100644 tests/baselines/reference/stringLiteralsWithSwitchStatements01.symbols create mode 100644 tests/baselines/reference/stringLiteralsWithSwitchStatements01.types create mode 100644 tests/baselines/reference/stringLiteralsWithSwitchStatements02.symbols create mode 100644 tests/baselines/reference/stringLiteralsWithSwitchStatements02.types create mode 100644 tests/baselines/reference/stringLiteralsWithSwitchStatements03.symbols create mode 100644 tests/baselines/reference/stringLiteralsWithSwitchStatements03.types create mode 100644 tests/baselines/reference/stringNamedPropertyDuplicates.symbols create mode 100644 tests/baselines/reference/stringNamedPropertyDuplicates.types create mode 100644 tests/baselines/reference/stringPropertyAccessWithError.symbols create mode 100644 tests/baselines/reference/stringPropertyAccessWithError.types create mode 100644 tests/baselines/reference/subtypesOfTypeParameter.symbols create mode 100644 tests/baselines/reference/subtypesOfTypeParameter.types create mode 100644 tests/baselines/reference/subtypesOfTypeParameterWithConstraints.symbols create mode 100644 tests/baselines/reference/subtypesOfTypeParameterWithConstraints.types create mode 100644 tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.symbols create mode 100644 tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.types create mode 100644 tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.symbols create mode 100644 tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.types create mode 100644 tests/baselines/reference/subtypesOfUnion.symbols create mode 100644 tests/baselines/reference/subtypesOfUnion.types create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesA.symbols create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesA.types create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesWithOptionalParameters.symbols create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesWithOptionalParameters.types create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesWithRestParameters.symbols create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesWithRestParameters.types create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesWithSpecializedSignatures.symbols create mode 100644 tests/baselines/reference/subtypingWithCallSignaturesWithSpecializedSignatures.types create mode 100644 tests/baselines/reference/subtypingWithConstructSignaturesWithOptionalParameters.symbols create mode 100644 tests/baselines/reference/subtypingWithConstructSignaturesWithOptionalParameters.types create mode 100644 tests/baselines/reference/subtypingWithConstructSignaturesWithSpecializedSignatures.symbols create mode 100644 tests/baselines/reference/subtypingWithConstructSignaturesWithSpecializedSignatures.types create mode 100644 tests/baselines/reference/subtypingWithGenericCallSignaturesWithOptionalParameters.symbols create mode 100644 tests/baselines/reference/subtypingWithGenericCallSignaturesWithOptionalParameters.types create mode 100644 tests/baselines/reference/subtypingWithGenericConstructSignaturesWithOptionalParameters.symbols create mode 100644 tests/baselines/reference/subtypingWithGenericConstructSignaturesWithOptionalParameters.types create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer.symbols create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer.types create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer2.symbols create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer2.types create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer3.symbols create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer3.types create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer4.symbols create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer4.types create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer5.symbols create mode 100644 tests/baselines/reference/subtypingWithNumericIndexer5.types create mode 100644 tests/baselines/reference/subtypingWithObjectMembers.symbols create mode 100644 tests/baselines/reference/subtypingWithObjectMembers.types create mode 100644 tests/baselines/reference/subtypingWithObjectMembers2.symbols create mode 100644 tests/baselines/reference/subtypingWithObjectMembers2.types create mode 100644 tests/baselines/reference/subtypingWithObjectMembers3.symbols create mode 100644 tests/baselines/reference/subtypingWithObjectMembers3.types create mode 100644 tests/baselines/reference/subtypingWithObjectMembers5.symbols create mode 100644 tests/baselines/reference/subtypingWithObjectMembers5.types create mode 100644 tests/baselines/reference/subtypingWithObjectMembersAccessibility.symbols create mode 100644 tests/baselines/reference/subtypingWithObjectMembersAccessibility.types create mode 100644 tests/baselines/reference/subtypingWithObjectMembersAccessibility2.symbols create mode 100644 tests/baselines/reference/subtypingWithObjectMembersAccessibility2.types create mode 100644 tests/baselines/reference/subtypingWithObjectMembersOptionality2.symbols create mode 100644 tests/baselines/reference/subtypingWithObjectMembersOptionality2.types create mode 100644 tests/baselines/reference/subtypingWithStringIndexer.symbols create mode 100644 tests/baselines/reference/subtypingWithStringIndexer.types create mode 100644 tests/baselines/reference/subtypingWithStringIndexer2.symbols create mode 100644 tests/baselines/reference/subtypingWithStringIndexer2.types create mode 100644 tests/baselines/reference/subtypingWithStringIndexer3.symbols create mode 100644 tests/baselines/reference/subtypingWithStringIndexer3.types create mode 100644 tests/baselines/reference/subtypingWithStringIndexer4.symbols create mode 100644 tests/baselines/reference/subtypingWithStringIndexer4.types create mode 100644 tests/baselines/reference/super.symbols create mode 100644 tests/baselines/reference/super.types create mode 100644 tests/baselines/reference/super1.symbols create mode 100644 tests/baselines/reference/super1.types create mode 100644 tests/baselines/reference/superAccess.symbols create mode 100644 tests/baselines/reference/superAccess.types create mode 100644 tests/baselines/reference/superAccess2.symbols create mode 100644 tests/baselines/reference/superAccess2.types create mode 100644 tests/baselines/reference/superCallArgsMustMatch.symbols create mode 100644 tests/baselines/reference/superCallArgsMustMatch.types create mode 100644 tests/baselines/reference/superCallAssignResult.symbols create mode 100644 tests/baselines/reference/superCallAssignResult.types create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing3.symbols create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing3.types create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing4.symbols create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing4.types create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing6.symbols create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing6.types create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing7.symbols create mode 100644 tests/baselines/reference/superCallBeforeThisAccessing7.types create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.symbols create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.types create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.symbols create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.types create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.symbols create mode 100644 tests/baselines/reference/superCallFromClassThatDerivesNonGenericTypeButWithTypeArguments1.types create mode 100644 tests/baselines/reference/superCallFromClassThatHasNoBaseType1.symbols create mode 100644 tests/baselines/reference/superCallFromClassThatHasNoBaseType1.types create mode 100644 tests/baselines/reference/superCallFromFunction1.symbols create mode 100644 tests/baselines/reference/superCallFromFunction1.types create mode 100644 tests/baselines/reference/superCallInConstructorWithNoBaseType.symbols create mode 100644 tests/baselines/reference/superCallInConstructorWithNoBaseType.types create mode 100644 tests/baselines/reference/superCallInNonStaticMethod.symbols create mode 100644 tests/baselines/reference/superCallInNonStaticMethod.types create mode 100644 tests/baselines/reference/superCallInStaticMethod.symbols create mode 100644 tests/baselines/reference/superCallInStaticMethod.types create mode 100644 tests/baselines/reference/superCallInsideClassDeclaration.symbols create mode 100644 tests/baselines/reference/superCallInsideClassDeclaration.types create mode 100644 tests/baselines/reference/superCallInsideClassExpression.symbols create mode 100644 tests/baselines/reference/superCallInsideClassExpression.types create mode 100644 tests/baselines/reference/superCallOutsideConstructor.symbols create mode 100644 tests/baselines/reference/superCallOutsideConstructor.types create mode 100644 tests/baselines/reference/superCallParameterContextualTyping2.symbols create mode 100644 tests/baselines/reference/superCallParameterContextualTyping2.types create mode 100644 tests/baselines/reference/superCallWithMissingBaseClass.symbols create mode 100644 tests/baselines/reference/superCallWithMissingBaseClass.types create mode 100644 tests/baselines/reference/superCallsInConstructor.symbols create mode 100644 tests/baselines/reference/superCallsInConstructor.types create mode 100644 tests/baselines/reference/superErrors.symbols create mode 100644 tests/baselines/reference/superErrors.types create mode 100644 tests/baselines/reference/superInConstructorParam1.symbols create mode 100644 tests/baselines/reference/superInConstructorParam1.types create mode 100644 tests/baselines/reference/superInLambdas.symbols create mode 100644 tests/baselines/reference/superInLambdas.types create mode 100644 tests/baselines/reference/superInObjectLiterals_ES5.symbols create mode 100644 tests/baselines/reference/superInObjectLiterals_ES5.types create mode 100644 tests/baselines/reference/superInObjectLiterals_ES6.symbols create mode 100644 tests/baselines/reference/superInObjectLiterals_ES6.types create mode 100644 tests/baselines/reference/superNewCall1.symbols create mode 100644 tests/baselines/reference/superNewCall1.types create mode 100644 tests/baselines/reference/superPropertyAccess.symbols create mode 100644 tests/baselines/reference/superPropertyAccess.types create mode 100644 tests/baselines/reference/superPropertyAccess1.symbols create mode 100644 tests/baselines/reference/superPropertyAccess1.types create mode 100644 tests/baselines/reference/superPropertyAccess2.symbols create mode 100644 tests/baselines/reference/superPropertyAccess2.types create mode 100644 tests/baselines/reference/superPropertyAccessInSuperCall01.symbols create mode 100644 tests/baselines/reference/superPropertyAccessInSuperCall01.types create mode 100644 tests/baselines/reference/superPropertyAccess_ES5.symbols create mode 100644 tests/baselines/reference/superPropertyAccess_ES5.types create mode 100644 tests/baselines/reference/superPropertyInConstructorBeforeSuperCall.symbols create mode 100644 tests/baselines/reference/superPropertyInConstructorBeforeSuperCall.types create mode 100644 tests/baselines/reference/superSymbolIndexedAccess3.symbols create mode 100644 tests/baselines/reference/superSymbolIndexedAccess3.types create mode 100644 tests/baselines/reference/superSymbolIndexedAccess4.symbols create mode 100644 tests/baselines/reference/superSymbolIndexedAccess4.types create mode 100644 tests/baselines/reference/superWithTypeArgument.symbols create mode 100644 tests/baselines/reference/superWithTypeArgument.types create mode 100644 tests/baselines/reference/superWithTypeArgument2.symbols create mode 100644 tests/baselines/reference/superWithTypeArgument2.types create mode 100644 tests/baselines/reference/superWithTypeArgument3.symbols create mode 100644 tests/baselines/reference/superWithTypeArgument3.types create mode 100644 tests/baselines/reference/super_inside-object-literal-getters-and-setters.symbols create mode 100644 tests/baselines/reference/super_inside-object-literal-getters-and-setters.types create mode 100644 tests/baselines/reference/switchAssignmentCompat.symbols create mode 100644 tests/baselines/reference/switchAssignmentCompat.types create mode 100644 tests/baselines/reference/switchCaseCircularRefeference.symbols create mode 100644 tests/baselines/reference/switchCaseCircularRefeference.types create mode 100644 tests/baselines/reference/switchCaseWithIntersectionTypes01.symbols create mode 100644 tests/baselines/reference/switchCaseWithIntersectionTypes01.types create mode 100644 tests/baselines/reference/switchCaseWithUnionTypes01.symbols create mode 100644 tests/baselines/reference/switchCaseWithUnionTypes01.types create mode 100644 tests/baselines/reference/switchCasesExpressionTypeMismatch.symbols create mode 100644 tests/baselines/reference/switchCasesExpressionTypeMismatch.types create mode 100644 tests/baselines/reference/switchStatements.symbols create mode 100644 tests/baselines/reference/switchStatements.types create mode 100644 tests/baselines/reference/switchStatementsWithMultipleDefaults.symbols create mode 100644 tests/baselines/reference/switchStatementsWithMultipleDefaults.types create mode 100644 tests/baselines/reference/switchStatementsWithMultipleDefaults1.symbols create mode 100644 tests/baselines/reference/switchStatementsWithMultipleDefaults1.types create mode 100644 tests/baselines/reference/symbolDeclarationEmit12.symbols create mode 100644 tests/baselines/reference/symbolDeclarationEmit12.types create mode 100644 tests/baselines/reference/symbolProperty10.symbols create mode 100644 tests/baselines/reference/symbolProperty10.types create mode 100644 tests/baselines/reference/symbolProperty12.symbols create mode 100644 tests/baselines/reference/symbolProperty12.types create mode 100644 tests/baselines/reference/symbolProperty17.symbols create mode 100644 tests/baselines/reference/symbolProperty17.types create mode 100644 tests/baselines/reference/symbolProperty21.symbols create mode 100644 tests/baselines/reference/symbolProperty21.types create mode 100644 tests/baselines/reference/symbolProperty24.symbols create mode 100644 tests/baselines/reference/symbolProperty24.types create mode 100644 tests/baselines/reference/symbolProperty25.symbols create mode 100644 tests/baselines/reference/symbolProperty25.types create mode 100644 tests/baselines/reference/symbolProperty29.symbols create mode 100644 tests/baselines/reference/symbolProperty29.types create mode 100644 tests/baselines/reference/symbolProperty3.symbols create mode 100644 tests/baselines/reference/symbolProperty3.types create mode 100644 tests/baselines/reference/symbolProperty30.symbols create mode 100644 tests/baselines/reference/symbolProperty30.types create mode 100644 tests/baselines/reference/symbolProperty31.symbols create mode 100644 tests/baselines/reference/symbolProperty31.types create mode 100644 tests/baselines/reference/symbolProperty32.symbols create mode 100644 tests/baselines/reference/symbolProperty32.types create mode 100644 tests/baselines/reference/symbolProperty33.symbols create mode 100644 tests/baselines/reference/symbolProperty33.types create mode 100644 tests/baselines/reference/symbolProperty34.symbols create mode 100644 tests/baselines/reference/symbolProperty34.types create mode 100644 tests/baselines/reference/symbolProperty35.symbols create mode 100644 tests/baselines/reference/symbolProperty35.types create mode 100644 tests/baselines/reference/symbolProperty36.symbols create mode 100644 tests/baselines/reference/symbolProperty36.types create mode 100644 tests/baselines/reference/symbolProperty39.symbols create mode 100644 tests/baselines/reference/symbolProperty39.types create mode 100644 tests/baselines/reference/symbolProperty42.symbols create mode 100644 tests/baselines/reference/symbolProperty42.types create mode 100644 tests/baselines/reference/symbolProperty43.symbols create mode 100644 tests/baselines/reference/symbolProperty43.types create mode 100644 tests/baselines/reference/symbolProperty44.symbols create mode 100644 tests/baselines/reference/symbolProperty44.types create mode 100644 tests/baselines/reference/symbolProperty46.symbols create mode 100644 tests/baselines/reference/symbolProperty46.types create mode 100644 tests/baselines/reference/symbolProperty47.symbols create mode 100644 tests/baselines/reference/symbolProperty47.types create mode 100644 tests/baselines/reference/symbolProperty48.symbols create mode 100644 tests/baselines/reference/symbolProperty48.types create mode 100644 tests/baselines/reference/symbolProperty49.symbols create mode 100644 tests/baselines/reference/symbolProperty49.types create mode 100644 tests/baselines/reference/symbolProperty52.symbols create mode 100644 tests/baselines/reference/symbolProperty52.types create mode 100644 tests/baselines/reference/symbolProperty53.symbols create mode 100644 tests/baselines/reference/symbolProperty53.types create mode 100644 tests/baselines/reference/symbolProperty54.symbols create mode 100644 tests/baselines/reference/symbolProperty54.types create mode 100644 tests/baselines/reference/symbolProperty58.symbols create mode 100644 tests/baselines/reference/symbolProperty58.types create mode 100644 tests/baselines/reference/symbolProperty59.symbols create mode 100644 tests/baselines/reference/symbolProperty59.types create mode 100644 tests/baselines/reference/symbolProperty7.symbols create mode 100644 tests/baselines/reference/symbolProperty7.types create mode 100644 tests/baselines/reference/symbolProperty9.symbols create mode 100644 tests/baselines/reference/symbolProperty9.types create mode 100644 tests/baselines/reference/symbolType1.symbols create mode 100644 tests/baselines/reference/symbolType1.types create mode 100644 tests/baselines/reference/symbolType10.symbols create mode 100644 tests/baselines/reference/symbolType10.types create mode 100644 tests/baselines/reference/symbolType12.symbols create mode 100644 tests/baselines/reference/symbolType12.types create mode 100644 tests/baselines/reference/symbolType13.symbols create mode 100644 tests/baselines/reference/symbolType13.types create mode 100644 tests/baselines/reference/symbolType14.symbols create mode 100644 tests/baselines/reference/symbolType14.types create mode 100644 tests/baselines/reference/symbolType15.symbols create mode 100644 tests/baselines/reference/symbolType15.types create mode 100644 tests/baselines/reference/symbolType2.symbols create mode 100644 tests/baselines/reference/symbolType2.types create mode 100644 tests/baselines/reference/symbolType20.symbols create mode 100644 tests/baselines/reference/symbolType20.types create mode 100644 tests/baselines/reference/symbolType3.symbols create mode 100644 tests/baselines/reference/symbolType3.types create mode 100644 tests/baselines/reference/symbolType4.symbols create mode 100644 tests/baselines/reference/symbolType4.types create mode 100644 tests/baselines/reference/symbolType5.symbols create mode 100644 tests/baselines/reference/symbolType5.types create mode 100644 tests/baselines/reference/symbolType6.symbols create mode 100644 tests/baselines/reference/symbolType6.types create mode 100644 tests/baselines/reference/symbolType7.symbols create mode 100644 tests/baselines/reference/symbolType7.types create mode 100644 tests/baselines/reference/symbolType8.symbols create mode 100644 tests/baselines/reference/symbolType8.types create mode 100644 tests/baselines/reference/symbolType9.symbols create mode 100644 tests/baselines/reference/symbolType9.types create mode 100644 tests/baselines/reference/syntaxErrors.symbols create mode 100644 tests/baselines/reference/syntaxErrors.types create mode 100644 tests/baselines/reference/systemExportAssignment2.symbols create mode 100644 tests/baselines/reference/systemExportAssignment2.types create mode 100644 tests/baselines/reference/systemModule10.symbols create mode 100644 tests/baselines/reference/systemModule10.types create mode 100644 tests/baselines/reference/systemModule10_ES5.symbols create mode 100644 tests/baselines/reference/systemModule10_ES5.types create mode 100644 tests/baselines/reference/systemModule11.symbols create mode 100644 tests/baselines/reference/systemModule11.types create mode 100644 tests/baselines/reference/systemModule12.symbols create mode 100644 tests/baselines/reference/systemModule12.types create mode 100644 tests/baselines/reference/systemModule14.symbols create mode 100644 tests/baselines/reference/systemModule14.types create mode 100644 tests/baselines/reference/systemModule16.symbols create mode 100644 tests/baselines/reference/systemModule16.types create mode 100644 tests/baselines/reference/systemModule2.symbols create mode 100644 tests/baselines/reference/systemModule2.types create mode 100644 tests/baselines/reference/systemModule9.symbols create mode 100644 tests/baselines/reference/systemModule9.types create mode 100644 tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsTypeArgumentInference.types create mode 100644 tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsTypeArgumentInferenceES6.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTags.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithIncompatibleTypedTagsES6.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution1_ES6.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithOverloadResolution3_ES6.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.types create mode 100644 tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.symbols create mode 100644 tests/baselines/reference/taggedTemplateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate1.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteNoSubstitutionTemplate2.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions1.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions2.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions3.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions4.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions5.types create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.symbols create mode 100644 tests/baselines/reference/taggedTemplatesWithIncompleteTemplateExpressions6.types create mode 100644 tests/baselines/reference/targetTypeBaseCalls.symbols create mode 100644 tests/baselines/reference/targetTypeBaseCalls.types create mode 100644 tests/baselines/reference/targetTypeCastTest.symbols create mode 100644 tests/baselines/reference/targetTypeCastTest.types create mode 100644 tests/baselines/reference/targetTypeTest1.symbols create mode 100644 tests/baselines/reference/targetTypeTest1.types create mode 100644 tests/baselines/reference/targetTypeTest3.symbols create mode 100644 tests/baselines/reference/targetTypeTest3.types create mode 100644 tests/baselines/reference/targetTypeVoidFunc.symbols create mode 100644 tests/baselines/reference/targetTypeVoidFunc.types create mode 100644 tests/baselines/reference/templateStringBinaryOperationsES6Invalid.symbols create mode 100644 tests/baselines/reference/templateStringBinaryOperationsES6Invalid.types create mode 100644 tests/baselines/reference/templateStringBinaryOperationsInvalid.symbols create mode 100644 tests/baselines/reference/templateStringBinaryOperationsInvalid.types create mode 100644 tests/baselines/reference/templateStringInCallExpression.symbols create mode 100644 tests/baselines/reference/templateStringInCallExpression.types create mode 100644 tests/baselines/reference/templateStringInCallExpressionES6.symbols create mode 100644 tests/baselines/reference/templateStringInCallExpressionES6.types create mode 100644 tests/baselines/reference/templateStringInDivision.symbols create mode 100644 tests/baselines/reference/templateStringInDivision.types create mode 100644 tests/baselines/reference/templateStringInFunctionParameterType.symbols create mode 100644 tests/baselines/reference/templateStringInFunctionParameterType.types create mode 100644 tests/baselines/reference/templateStringInFunctionParameterTypeES6.symbols create mode 100644 tests/baselines/reference/templateStringInFunctionParameterTypeES6.types create mode 100644 tests/baselines/reference/templateStringInInstanceOf.symbols create mode 100644 tests/baselines/reference/templateStringInInstanceOf.types create mode 100644 tests/baselines/reference/templateStringInInstanceOfES6.symbols create mode 100644 tests/baselines/reference/templateStringInInstanceOfES6.types create mode 100644 tests/baselines/reference/templateStringInModuleName.symbols create mode 100644 tests/baselines/reference/templateStringInModuleName.types create mode 100644 tests/baselines/reference/templateStringInModuleNameES6.symbols create mode 100644 tests/baselines/reference/templateStringInModuleNameES6.types create mode 100644 tests/baselines/reference/templateStringInModulo.symbols create mode 100644 tests/baselines/reference/templateStringInModulo.types create mode 100644 tests/baselines/reference/templateStringInModuloES6.symbols create mode 100644 tests/baselines/reference/templateStringInModuloES6.types create mode 100644 tests/baselines/reference/templateStringInMultiplication.symbols create mode 100644 tests/baselines/reference/templateStringInMultiplication.types create mode 100644 tests/baselines/reference/templateStringInMultiplicationES6.symbols create mode 100644 tests/baselines/reference/templateStringInMultiplicationES6.types create mode 100644 tests/baselines/reference/templateStringInNewExpression.symbols create mode 100644 tests/baselines/reference/templateStringInNewExpression.types create mode 100644 tests/baselines/reference/templateStringInNewExpressionES6.symbols create mode 100644 tests/baselines/reference/templateStringInNewExpressionES6.types create mode 100644 tests/baselines/reference/templateStringInNewOperator.symbols create mode 100644 tests/baselines/reference/templateStringInNewOperator.types create mode 100644 tests/baselines/reference/templateStringInNewOperatorES6.symbols create mode 100644 tests/baselines/reference/templateStringInNewOperatorES6.types create mode 100644 tests/baselines/reference/templateStringInObjectLiteral.symbols create mode 100644 tests/baselines/reference/templateStringInObjectLiteral.types create mode 100644 tests/baselines/reference/templateStringInObjectLiteralES6.symbols create mode 100644 tests/baselines/reference/templateStringInObjectLiteralES6.types create mode 100644 tests/baselines/reference/templateStringInPropertyName1.symbols create mode 100644 tests/baselines/reference/templateStringInPropertyName1.types create mode 100644 tests/baselines/reference/templateStringInPropertyName2.symbols create mode 100644 tests/baselines/reference/templateStringInPropertyName2.types create mode 100644 tests/baselines/reference/templateStringInPropertyNameES6_1.symbols create mode 100644 tests/baselines/reference/templateStringInPropertyNameES6_1.types create mode 100644 tests/baselines/reference/templateStringInPropertyNameES6_2.symbols create mode 100644 tests/baselines/reference/templateStringInPropertyNameES6_2.types create mode 100644 tests/baselines/reference/templateStringInTaggedTemplate.symbols create mode 100644 tests/baselines/reference/templateStringInTaggedTemplate.types create mode 100644 tests/baselines/reference/templateStringInTaggedTemplateES6.symbols create mode 100644 tests/baselines/reference/templateStringInTaggedTemplateES6.types create mode 100644 tests/baselines/reference/templateStringUnterminated1.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated1.types create mode 100644 tests/baselines/reference/templateStringUnterminated1_ES6.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated1_ES6.types create mode 100644 tests/baselines/reference/templateStringUnterminated2.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated2.types create mode 100644 tests/baselines/reference/templateStringUnterminated2_ES6.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated2_ES6.types create mode 100644 tests/baselines/reference/templateStringUnterminated3.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated3.types create mode 100644 tests/baselines/reference/templateStringUnterminated3_ES6.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated3_ES6.types create mode 100644 tests/baselines/reference/templateStringUnterminated4.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated4.types create mode 100644 tests/baselines/reference/templateStringUnterminated4_ES6.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated4_ES6.types create mode 100644 tests/baselines/reference/templateStringUnterminated5.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated5.types create mode 100644 tests/baselines/reference/templateStringUnterminated5_ES6.symbols create mode 100644 tests/baselines/reference/templateStringUnterminated5_ES6.types create mode 100644 tests/baselines/reference/templateStringWithEmbeddedInstanceOf.symbols create mode 100644 tests/baselines/reference/templateStringWithEmbeddedInstanceOf.types create mode 100644 tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.symbols create mode 100644 tests/baselines/reference/templateStringWithEmbeddedInstanceOfES6.types create mode 100644 tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.symbols create mode 100644 tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.types create mode 100644 tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.symbols create mode 100644 tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.types create mode 100644 tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.symbols create mode 100644 tests/baselines/reference/templateStringsArrayTypeNotDefinedES5Mode.types create mode 100644 tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.symbols create mode 100644 tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.types create mode 100644 tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.symbols create mode 100644 tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpression.types create mode 100644 tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.symbols create mode 100644 tests/baselines/reference/templateStringsWithTypeErrorInFunctionExpressionsInSubstitutionExpressionES6.types create mode 100644 tests/baselines/reference/thisBinding.symbols create mode 100644 tests/baselines/reference/thisBinding.types create mode 100644 tests/baselines/reference/thisInAccessors.symbols create mode 100644 tests/baselines/reference/thisInAccessors.types create mode 100644 tests/baselines/reference/thisInArrowFunctionInStaticInitializer1.symbols create mode 100644 tests/baselines/reference/thisInArrowFunctionInStaticInitializer1.types create mode 100644 tests/baselines/reference/thisInConstructorParameter1.symbols create mode 100644 tests/baselines/reference/thisInConstructorParameter1.types create mode 100644 tests/baselines/reference/thisInConstructorParameter2.symbols create mode 100644 tests/baselines/reference/thisInConstructorParameter2.types create mode 100644 tests/baselines/reference/thisInInvalidContexts.symbols create mode 100644 tests/baselines/reference/thisInInvalidContexts.types create mode 100644 tests/baselines/reference/thisInInvalidContextsExternalModule.symbols create mode 100644 tests/baselines/reference/thisInInvalidContextsExternalModule.types create mode 100644 tests/baselines/reference/thisInModule.symbols create mode 100644 tests/baselines/reference/thisInModule.types create mode 100644 tests/baselines/reference/thisInOuterClassBody.symbols create mode 100644 tests/baselines/reference/thisInOuterClassBody.types create mode 100644 tests/baselines/reference/thisInStatics.symbols create mode 100644 tests/baselines/reference/thisInStatics.types create mode 100644 tests/baselines/reference/thisInSuperCall.symbols create mode 100644 tests/baselines/reference/thisInSuperCall.types create mode 100644 tests/baselines/reference/thisInSuperCall1.symbols create mode 100644 tests/baselines/reference/thisInSuperCall1.types create mode 100644 tests/baselines/reference/thisInSuperCall2.symbols create mode 100644 tests/baselines/reference/thisInSuperCall2.types create mode 100644 tests/baselines/reference/thisInSuperCall3.symbols create mode 100644 tests/baselines/reference/thisInSuperCall3.types create mode 100644 tests/baselines/reference/thisKeyword.symbols create mode 100644 tests/baselines/reference/thisKeyword.types create mode 100644 tests/baselines/reference/thisTypeErrors.symbols create mode 100644 tests/baselines/reference/thisTypeErrors.types create mode 100644 tests/baselines/reference/thisTypeErrors2.symbols create mode 100644 tests/baselines/reference/thisTypeErrors2.types create mode 100644 tests/baselines/reference/thisTypeInAccessorsNegative.symbols create mode 100644 tests/baselines/reference/thisTypeInAccessorsNegative.types create mode 100644 tests/baselines/reference/thisTypeInFunctionsNegative.symbols create mode 100644 tests/baselines/reference/thisTypeInFunctionsNegative.types create mode 100644 tests/baselines/reference/thisWhenTypeCheckFails.symbols create mode 100644 tests/baselines/reference/thisWhenTypeCheckFails.types create mode 100644 tests/baselines/reference/this_inside-enum-should-not-be-allowed.symbols create mode 100644 tests/baselines/reference/this_inside-enum-should-not-be-allowed.types create mode 100644 tests/baselines/reference/this_inside-object-literal-getters-and-setters.symbols create mode 100644 tests/baselines/reference/this_inside-object-literal-getters-and-setters.types create mode 100644 tests/baselines/reference/throwWithoutNewLine1.symbols create mode 100644 tests/baselines/reference/throwWithoutNewLine1.types create mode 100644 tests/baselines/reference/throwWithoutNewLine2.symbols create mode 100644 tests/baselines/reference/throwWithoutNewLine2.types create mode 100644 tests/baselines/reference/tooManyTypeParameters1.symbols create mode 100644 tests/baselines/reference/tooManyTypeParameters1.types create mode 100644 tests/baselines/reference/topLevelFileModuleMissing.symbols create mode 100644 tests/baselines/reference/topLevelFileModuleMissing.types create mode 100644 tests/baselines/reference/topLevelLambda.symbols create mode 100644 tests/baselines/reference/topLevelLambda.types create mode 100644 tests/baselines/reference/topLevelModuleDeclarationAndFile.symbols create mode 100644 tests/baselines/reference/topLevelModuleDeclarationAndFile.types create mode 100644 tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.symbols create mode 100644 tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.types create mode 100644 tests/baselines/reference/trailingCommasInGetter.symbols create mode 100644 tests/baselines/reference/trailingCommasInGetter.types create mode 100644 tests/baselines/reference/tsxAttributeErrors.symbols create mode 100644 tests/baselines/reference/tsxAttributeErrors.types create mode 100644 tests/baselines/reference/tsxAttributeInvalidNames.symbols create mode 100644 tests/baselines/reference/tsxAttributeInvalidNames.types create mode 100644 tests/baselines/reference/tsxAttributeResolution1.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution1.types create mode 100644 tests/baselines/reference/tsxAttributeResolution10.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution10.types create mode 100644 tests/baselines/reference/tsxAttributeResolution11.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution11.types create mode 100644 tests/baselines/reference/tsxAttributeResolution12.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution12.types create mode 100644 tests/baselines/reference/tsxAttributeResolution14.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution14.types create mode 100644 tests/baselines/reference/tsxAttributeResolution15.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution15.types create mode 100644 tests/baselines/reference/tsxAttributeResolution2.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution2.types create mode 100644 tests/baselines/reference/tsxAttributeResolution3.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution3.types create mode 100644 tests/baselines/reference/tsxAttributeResolution4.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution4.types create mode 100644 tests/baselines/reference/tsxAttributeResolution5.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution5.types create mode 100644 tests/baselines/reference/tsxAttributeResolution6.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution6.types create mode 100644 tests/baselines/reference/tsxAttributeResolution7.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution7.types create mode 100644 tests/baselines/reference/tsxAttributeResolution9.symbols create mode 100644 tests/baselines/reference/tsxAttributeResolution9.types create mode 100644 tests/baselines/reference/tsxDefaultAttributesResolution3.symbols create mode 100644 tests/baselines/reference/tsxDefaultAttributesResolution3.types create mode 100644 tests/baselines/reference/tsxDynamicTagName2.symbols create mode 100644 tests/baselines/reference/tsxDynamicTagName2.types create mode 100644 tests/baselines/reference/tsxDynamicTagName3.symbols create mode 100644 tests/baselines/reference/tsxDynamicTagName3.types create mode 100644 tests/baselines/reference/tsxDynamicTagName7.symbols create mode 100644 tests/baselines/reference/tsxDynamicTagName7.types create mode 100644 tests/baselines/reference/tsxElementResolution1.symbols create mode 100644 tests/baselines/reference/tsxElementResolution1.types create mode 100644 tests/baselines/reference/tsxElementResolution10.symbols create mode 100644 tests/baselines/reference/tsxElementResolution10.types create mode 100644 tests/baselines/reference/tsxElementResolution11.symbols create mode 100644 tests/baselines/reference/tsxElementResolution11.types create mode 100644 tests/baselines/reference/tsxElementResolution12.symbols create mode 100644 tests/baselines/reference/tsxElementResolution12.types create mode 100644 tests/baselines/reference/tsxElementResolution15.symbols create mode 100644 tests/baselines/reference/tsxElementResolution15.types create mode 100644 tests/baselines/reference/tsxElementResolution16.symbols create mode 100644 tests/baselines/reference/tsxElementResolution16.types create mode 100644 tests/baselines/reference/tsxElementResolution18.symbols create mode 100644 tests/baselines/reference/tsxElementResolution18.types create mode 100644 tests/baselines/reference/tsxElementResolution3.symbols create mode 100644 tests/baselines/reference/tsxElementResolution3.types create mode 100644 tests/baselines/reference/tsxElementResolution4.symbols create mode 100644 tests/baselines/reference/tsxElementResolution4.types create mode 100644 tests/baselines/reference/tsxElementResolution6.symbols create mode 100644 tests/baselines/reference/tsxElementResolution6.types create mode 100644 tests/baselines/reference/tsxElementResolution7.symbols create mode 100644 tests/baselines/reference/tsxElementResolution7.types create mode 100644 tests/baselines/reference/tsxElementResolution8.symbols create mode 100644 tests/baselines/reference/tsxElementResolution8.types create mode 100644 tests/baselines/reference/tsxErrorRecovery1.symbols create mode 100644 tests/baselines/reference/tsxErrorRecovery1.types create mode 100644 tests/baselines/reference/tsxErrorRecovery2.symbols create mode 100644 tests/baselines/reference/tsxErrorRecovery2.types create mode 100644 tests/baselines/reference/tsxErrorRecovery3.symbols create mode 100644 tests/baselines/reference/tsxErrorRecovery3.types create mode 100644 tests/baselines/reference/tsxGenericAttributesType2.symbols create mode 100644 tests/baselines/reference/tsxGenericAttributesType2.types create mode 100644 tests/baselines/reference/tsxGenericAttributesType4.symbols create mode 100644 tests/baselines/reference/tsxGenericAttributesType4.types create mode 100644 tests/baselines/reference/tsxGenericAttributesType5.symbols create mode 100644 tests/baselines/reference/tsxGenericAttributesType5.types create mode 100644 tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter2.symbols create mode 100644 tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter2.types create mode 100644 tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter3.symbols create mode 100644 tests/baselines/reference/tsxReactComponentWithDefaultTypeParameter3.types create mode 100644 tests/baselines/reference/tsxReactEmit4.symbols create mode 100644 tests/baselines/reference/tsxReactEmit4.types create mode 100644 tests/baselines/reference/tsxReactEmit7.symbols create mode 100644 tests/baselines/reference/tsxReactEmit7.types create mode 100644 tests/baselines/reference/tsxSfcReturnUndefinedStrictNullChecks.symbols create mode 100644 tests/baselines/reference/tsxSfcReturnUndefinedStrictNullChecks.types create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution10.symbols create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution10.types create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution12.symbols create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution12.types create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution14.symbols create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution14.types create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution16.symbols create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution16.types create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution2.symbols create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution2.types create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution5.symbols create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution5.types create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution6.symbols create mode 100644 tests/baselines/reference/tsxSpreadAttributesResolution6.types create mode 100644 tests/baselines/reference/tsxSpreadChildrenInvalidType.symbols create mode 100644 tests/baselines/reference/tsxSpreadChildrenInvalidType.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentOverload4.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentOverload4.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentOverload5.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentOverload5.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentWithDefaultTypeParameter2.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentWithDefaultTypeParameter2.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponents1.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponents1.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponents2.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponents2.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments2.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments2.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments4.types create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments5.symbols create mode 100644 tests/baselines/reference/tsxStatelessFunctionComponentsWithTypeArguments5.types create mode 100644 tests/baselines/reference/tsxUnionElementType2.symbols create mode 100644 tests/baselines/reference/tsxUnionElementType2.types create mode 100644 tests/baselines/reference/tsxUnionElementType4.symbols create mode 100644 tests/baselines/reference/tsxUnionElementType4.types create mode 100644 tests/baselines/reference/tsxUnionElementType6.symbols create mode 100644 tests/baselines/reference/tsxUnionElementType6.types create mode 100644 tests/baselines/reference/tsxUnionTypeComponent2.symbols create mode 100644 tests/baselines/reference/tsxUnionTypeComponent2.types create mode 100644 tests/baselines/reference/tupleTypes.symbols create mode 100644 tests/baselines/reference/tupleTypes.types create mode 100644 tests/baselines/reference/twoAccessorsWithSameName.symbols create mode 100644 tests/baselines/reference/twoAccessorsWithSameName.types create mode 100644 tests/baselines/reference/twoAccessorsWithSameName2.symbols create mode 100644 tests/baselines/reference/twoAccessorsWithSameName2.types create mode 100644 tests/baselines/reference/twoGenericInterfacesDifferingByTypeParameterName.symbols create mode 100644 tests/baselines/reference/twoGenericInterfacesDifferingByTypeParameterName.types create mode 100644 tests/baselines/reference/twoGenericInterfacesDifferingByTypeParameterName2.symbols create mode 100644 tests/baselines/reference/twoGenericInterfacesDifferingByTypeParameterName2.types create mode 100644 tests/baselines/reference/twoGenericInterfacesWithDifferentConstraints.symbols create mode 100644 tests/baselines/reference/twoGenericInterfacesWithDifferentConstraints.types create mode 100644 tests/baselines/reference/twoGenericInterfacesWithTheSameNameButDifferentArity.symbols create mode 100644 tests/baselines/reference/twoGenericInterfacesWithTheSameNameButDifferentArity.types create mode 100644 tests/baselines/reference/twoInterfacesDifferentRootModule.symbols create mode 100644 tests/baselines/reference/twoInterfacesDifferentRootModule.types create mode 100644 tests/baselines/reference/twoInterfacesDifferentRootModule2.symbols create mode 100644 tests/baselines/reference/twoInterfacesDifferentRootModule2.types create mode 100644 tests/baselines/reference/typeAliasesForObjectTypes.symbols create mode 100644 tests/baselines/reference/typeAliasesForObjectTypes.types create mode 100644 tests/baselines/reference/typeArgInference2.symbols create mode 100644 tests/baselines/reference/typeArgInference2.types create mode 100644 tests/baselines/reference/typeArgInference2WithError.symbols create mode 100644 tests/baselines/reference/typeArgInference2WithError.types create mode 100644 tests/baselines/reference/typeArgumentConstraintResolution1.symbols create mode 100644 tests/baselines/reference/typeArgumentConstraintResolution1.types create mode 100644 tests/baselines/reference/typeArgumentInference.symbols create mode 100644 tests/baselines/reference/typeArgumentInference.types create mode 100644 tests/baselines/reference/typeArgumentInferenceConstructSignatures.symbols create mode 100644 tests/baselines/reference/typeArgumentInferenceConstructSignatures.types create mode 100644 tests/baselines/reference/typeArgumentInferenceErrors.symbols create mode 100644 tests/baselines/reference/typeArgumentInferenceErrors.types create mode 100644 tests/baselines/reference/typeArgumentInferenceWithClassExpression2.symbols create mode 100644 tests/baselines/reference/typeArgumentInferenceWithClassExpression2.types create mode 100644 tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.symbols create mode 100644 tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.types create mode 100644 tests/baselines/reference/typeArgumentInferenceWithConstraints.symbols create mode 100644 tests/baselines/reference/typeArgumentInferenceWithConstraints.types create mode 100644 tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.symbols create mode 100644 tests/baselines/reference/typeArgumentInferenceWithObjectLiteral.types create mode 100644 tests/baselines/reference/typeArgumentsOnFunctionsWithNoTypeParameters.symbols create mode 100644 tests/baselines/reference/typeArgumentsOnFunctionsWithNoTypeParameters.types create mode 100644 tests/baselines/reference/typeArgumentsShouldDisallowNonGenericOverloads.symbols create mode 100644 tests/baselines/reference/typeArgumentsShouldDisallowNonGenericOverloads.types create mode 100644 tests/baselines/reference/typeArgumentsWithStringLiteralTypes01.symbols create mode 100644 tests/baselines/reference/typeArgumentsWithStringLiteralTypes01.types create mode 100644 tests/baselines/reference/typeAssertionToGenericFunctionType.symbols create mode 100644 tests/baselines/reference/typeAssertionToGenericFunctionType.types create mode 100644 tests/baselines/reference/typeAssertions.symbols create mode 100644 tests/baselines/reference/typeAssertions.types create mode 100644 tests/baselines/reference/typeAssertionsWithIntersectionTypes01.symbols create mode 100644 tests/baselines/reference/typeAssertionsWithIntersectionTypes01.types create mode 100644 tests/baselines/reference/typeAssertionsWithUnionTypes01.symbols create mode 100644 tests/baselines/reference/typeAssertionsWithUnionTypes01.types create mode 100644 tests/baselines/reference/typeCheckObjectLiteralMethodBody.symbols create mode 100644 tests/baselines/reference/typeCheckObjectLiteralMethodBody.types create mode 100644 tests/baselines/reference/typeCheckReturnExpression.symbols create mode 100644 tests/baselines/reference/typeCheckReturnExpression.types create mode 100644 tests/baselines/reference/typeCheckTypeArgument.symbols create mode 100644 tests/baselines/reference/typeCheckTypeArgument.types create mode 100644 tests/baselines/reference/typeCheckingInsideFunctionExpressionInArray.symbols create mode 100644 tests/baselines/reference/typeCheckingInsideFunctionExpressionInArray.types create mode 100644 tests/baselines/reference/typeComparisonCaching.symbols create mode 100644 tests/baselines/reference/typeComparisonCaching.types create mode 100644 tests/baselines/reference/typeGuardFunctionErrors.symbols create mode 100644 tests/baselines/reference/typeGuardFunctionErrors.types create mode 100644 tests/baselines/reference/typeGuardFunctionOfFormThisErrors.symbols create mode 100644 tests/baselines/reference/typeGuardFunctionOfFormThisErrors.types create mode 100644 tests/baselines/reference/typeGuardInClass.symbols create mode 100644 tests/baselines/reference/typeGuardInClass.types create mode 100644 tests/baselines/reference/typeGuardOfFormThisMember.symbols create mode 100644 tests/baselines/reference/typeGuardOfFormThisMember.types create mode 100644 tests/baselines/reference/typeGuardOfFormThisMemberErrors.symbols create mode 100644 tests/baselines/reference/typeGuardOfFormThisMemberErrors.types create mode 100644 tests/baselines/reference/typeGuardOfFormTypeOfEqualEqualHasNoEffect.symbols create mode 100644 tests/baselines/reference/typeGuardOfFormTypeOfEqualEqualHasNoEffect.types create mode 100644 tests/baselines/reference/typeGuardOfFormTypeOfNotEqualHasNoEffect.symbols create mode 100644 tests/baselines/reference/typeGuardOfFormTypeOfNotEqualHasNoEffect.types create mode 100644 tests/baselines/reference/typeGuardOfFormTypeOfOther.symbols create mode 100644 tests/baselines/reference/typeGuardOfFormTypeOfOther.types create mode 100644 tests/baselines/reference/typeGuardsDefeat.symbols create mode 100644 tests/baselines/reference/typeGuardsDefeat.types create mode 100644 tests/baselines/reference/typeGuardsInIfStatement.symbols create mode 100644 tests/baselines/reference/typeGuardsInIfStatement.types create mode 100644 tests/baselines/reference/typeGuardsWithAny.symbols create mode 100644 tests/baselines/reference/typeGuardsWithAny.types create mode 100644 tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.symbols create mode 100644 tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.types create mode 100644 tests/baselines/reference/typeIdentityConsidersBrands.symbols create mode 100644 tests/baselines/reference/typeIdentityConsidersBrands.types create mode 100644 tests/baselines/reference/typeInfer1.symbols create mode 100644 tests/baselines/reference/typeInfer1.types create mode 100644 tests/baselines/reference/typeInferenceConflictingCandidates.symbols create mode 100644 tests/baselines/reference/typeInferenceConflictingCandidates.types create mode 100644 tests/baselines/reference/typeMatch1.symbols create mode 100644 tests/baselines/reference/typeMatch1.types create mode 100644 tests/baselines/reference/typeMatch2.symbols create mode 100644 tests/baselines/reference/typeMatch2.types create mode 100644 tests/baselines/reference/typeName1.symbols create mode 100644 tests/baselines/reference/typeName1.types create mode 100644 tests/baselines/reference/typeOfEnumAndVarRedeclarations.symbols create mode 100644 tests/baselines/reference/typeOfEnumAndVarRedeclarations.types create mode 100644 tests/baselines/reference/typeOfOnTypeArg.symbols create mode 100644 tests/baselines/reference/typeOfOnTypeArg.types create mode 100644 tests/baselines/reference/typeOfOperator1.symbols create mode 100644 tests/baselines/reference/typeOfOperator1.types create mode 100644 tests/baselines/reference/typeOfThis.symbols create mode 100644 tests/baselines/reference/typeOfThis.types create mode 100644 tests/baselines/reference/typeOfThisInAccessor.symbols create mode 100644 tests/baselines/reference/typeOfThisInAccessor.types create mode 100644 tests/baselines/reference/typeOfThisInConstructorParamList.symbols create mode 100644 tests/baselines/reference/typeOfThisInConstructorParamList.types create mode 100644 tests/baselines/reference/typeOfThisInInstanceMember.symbols create mode 100644 tests/baselines/reference/typeOfThisInInstanceMember.types create mode 100644 tests/baselines/reference/typeOfThisInInstanceMember2.symbols create mode 100644 tests/baselines/reference/typeOfThisInInstanceMember2.types create mode 100644 tests/baselines/reference/typeOfThisInStaticMembers2.symbols create mode 100644 tests/baselines/reference/typeOfThisInStaticMembers2.types create mode 100644 tests/baselines/reference/typeOfThisInStatics.symbols create mode 100644 tests/baselines/reference/typeOfThisInStatics.types create mode 100644 tests/baselines/reference/typeParamExtendsOtherTypeParam.symbols create mode 100644 tests/baselines/reference/typeParamExtendsOtherTypeParam.types create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence.symbols create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence.types create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence2.symbols create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence2.types create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence3.symbols create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence3.types create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence4.symbols create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence4.types create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence5.symbols create mode 100644 tests/baselines/reference/typeParameterArgumentEquivalence5.types create mode 100644 tests/baselines/reference/typeParameterAsBaseClass.symbols create mode 100644 tests/baselines/reference/typeParameterAsBaseClass.types create mode 100644 tests/baselines/reference/typeParameterAsBaseType.symbols create mode 100644 tests/baselines/reference/typeParameterAsBaseType.types create mode 100644 tests/baselines/reference/typeParameterAsTypeParameterConstraint2.symbols create mode 100644 tests/baselines/reference/typeParameterAsTypeParameterConstraint2.types create mode 100644 tests/baselines/reference/typeParameterAssignability.symbols create mode 100644 tests/baselines/reference/typeParameterAssignability.types create mode 100644 tests/baselines/reference/typeParameterAssignability2.symbols create mode 100644 tests/baselines/reference/typeParameterAssignability2.types create mode 100644 tests/baselines/reference/typeParameterAssignability3.symbols create mode 100644 tests/baselines/reference/typeParameterAssignability3.types create mode 100644 tests/baselines/reference/typeParameterAssignmentCompat1.symbols create mode 100644 tests/baselines/reference/typeParameterAssignmentCompat1.types create mode 100644 tests/baselines/reference/typeParameterConstraints1.symbols create mode 100644 tests/baselines/reference/typeParameterConstraints1.types create mode 100644 tests/baselines/reference/typeParameterDiamond2.symbols create mode 100644 tests/baselines/reference/typeParameterDiamond2.types create mode 100644 tests/baselines/reference/typeParameterDiamond3.symbols create mode 100644 tests/baselines/reference/typeParameterDiamond3.types create mode 100644 tests/baselines/reference/typeParameterDiamond4.symbols create mode 100644 tests/baselines/reference/typeParameterDiamond4.types create mode 100644 tests/baselines/reference/typeParameterDirectlyConstrainedToItself.symbols create mode 100644 tests/baselines/reference/typeParameterDirectlyConstrainedToItself.types create mode 100644 tests/baselines/reference/typeParameterExplicitlyExtendsAny.symbols create mode 100644 tests/baselines/reference/typeParameterExplicitlyExtendsAny.types create mode 100644 tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments2.symbols create mode 100644 tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments2.types create mode 100644 tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments3.symbols create mode 100644 tests/baselines/reference/typeParameterFixingWithContextSensitiveArguments3.types create mode 100644 tests/baselines/reference/typeParameterHasSelfAsConstraint.symbols create mode 100644 tests/baselines/reference/typeParameterHasSelfAsConstraint.types create mode 100644 tests/baselines/reference/typeParameterIndirectlyConstrainedToItself.symbols create mode 100644 tests/baselines/reference/typeParameterIndirectlyConstrainedToItself.types create mode 100644 tests/baselines/reference/typeParameterUsedAsTypeParameterConstraint4.symbols create mode 100644 tests/baselines/reference/typeParameterUsedAsTypeParameterConstraint4.types create mode 100644 tests/baselines/reference/typeParameterWithInvalidConstraintType.symbols create mode 100644 tests/baselines/reference/typeParameterWithInvalidConstraintType.types create mode 100644 tests/baselines/reference/typeParametersAndParametersInComputedNames.symbols create mode 100644 tests/baselines/reference/typeParametersAndParametersInComputedNames.types create mode 100644 tests/baselines/reference/typeParametersInStaticAccessors.symbols create mode 100644 tests/baselines/reference/typeParametersInStaticAccessors.types create mode 100644 tests/baselines/reference/typeParametersInStaticMethods.symbols create mode 100644 tests/baselines/reference/typeParametersInStaticMethods.types create mode 100644 tests/baselines/reference/typeParametersInStaticProperties.symbols create mode 100644 tests/baselines/reference/typeParametersInStaticProperties.types create mode 100644 tests/baselines/reference/typeParametersShouldNotBeEqual.symbols create mode 100644 tests/baselines/reference/typeParametersShouldNotBeEqual.types create mode 100644 tests/baselines/reference/typeParametersShouldNotBeEqual2.symbols create mode 100644 tests/baselines/reference/typeParametersShouldNotBeEqual2.types create mode 100644 tests/baselines/reference/typeParametersShouldNotBeEqual3.symbols create mode 100644 tests/baselines/reference/typeParametersShouldNotBeEqual3.types create mode 100644 tests/baselines/reference/typePredicateOnVariableDeclaration01.symbols create mode 100644 tests/baselines/reference/typePredicateOnVariableDeclaration01.types create mode 100644 tests/baselines/reference/typePredicateOnVariableDeclaration02.symbols create mode 100644 tests/baselines/reference/typePredicateOnVariableDeclaration02.types create mode 100644 tests/baselines/reference/typeQueryOnClass.symbols create mode 100644 tests/baselines/reference/typeQueryOnClass.types create mode 100644 tests/baselines/reference/typeRelationships.symbols create mode 100644 tests/baselines/reference/typeRelationships.types create mode 100644 tests/baselines/reference/typeUsedAsValueError.symbols create mode 100644 tests/baselines/reference/typeUsedAsValueError.types create mode 100644 tests/baselines/reference/typeUsedAsValueError2.symbols create mode 100644 tests/baselines/reference/typeUsedAsValueError2.types create mode 100644 tests/baselines/reference/typeValueConflict1.symbols create mode 100644 tests/baselines/reference/typeValueConflict1.types create mode 100644 tests/baselines/reference/typeValueConflict2.symbols create mode 100644 tests/baselines/reference/typeValueConflict2.types create mode 100644 tests/baselines/reference/typecheckCommaExpression.symbols create mode 100644 tests/baselines/reference/typecheckCommaExpression.types create mode 100644 tests/baselines/reference/typecheckIfCondition.symbols create mode 100644 tests/baselines/reference/typecheckIfCondition.types create mode 100644 tests/baselines/reference/typedArraysCrossAssignability01.symbols create mode 100644 tests/baselines/reference/typedArraysCrossAssignability01.types create mode 100644 tests/baselines/reference/typeofANonExportedType.symbols create mode 100644 tests/baselines/reference/typeofANonExportedType.types create mode 100644 tests/baselines/reference/typeofAmbientExternalModules.symbols create mode 100644 tests/baselines/reference/typeofAmbientExternalModules.types create mode 100644 tests/baselines/reference/typeofAnExportedType.symbols create mode 100644 tests/baselines/reference/typeofAnExportedType.types create mode 100644 tests/baselines/reference/typeofClass.symbols create mode 100644 tests/baselines/reference/typeofClass.types create mode 100644 tests/baselines/reference/typeofClassWithPrivates.symbols create mode 100644 tests/baselines/reference/typeofClassWithPrivates.types create mode 100644 tests/baselines/reference/typeofExternalModules.symbols create mode 100644 tests/baselines/reference/typeofExternalModules.types create mode 100644 tests/baselines/reference/typeofInObjectLiteralType.symbols create mode 100644 tests/baselines/reference/typeofInObjectLiteralType.types create mode 100644 tests/baselines/reference/typeofInternalModules.symbols create mode 100644 tests/baselines/reference/typeofInternalModules.types create mode 100644 tests/baselines/reference/typeofOperatorInvalidOperations.symbols create mode 100644 tests/baselines/reference/typeofOperatorInvalidOperations.types create mode 100644 tests/baselines/reference/typeofOperatorWithAnyOtherType.symbols create mode 100644 tests/baselines/reference/typeofOperatorWithAnyOtherType.types create mode 100644 tests/baselines/reference/typeofOperatorWithStringType.symbols create mode 100644 tests/baselines/reference/typeofOperatorWithStringType.types create mode 100644 tests/baselines/reference/typeofProperty.symbols create mode 100644 tests/baselines/reference/typeofProperty.types create mode 100644 tests/baselines/reference/typeofSimple.symbols create mode 100644 tests/baselines/reference/typeofSimple.types create mode 100644 tests/baselines/reference/typeofTypeParameter.symbols create mode 100644 tests/baselines/reference/typeofTypeParameter.types create mode 100644 tests/baselines/reference/typeofUnknownSymbol.symbols create mode 100644 tests/baselines/reference/typeofUnknownSymbol.types create mode 100644 tests/baselines/reference/types.asyncGenerators.esnext.2.symbols create mode 100644 tests/baselines/reference/types.asyncGenerators.esnext.2.types create mode 100644 tests/baselines/reference/types.forAwait.esnext.2.symbols create mode 100644 tests/baselines/reference/types.forAwait.esnext.2.types create mode 100644 tests/baselines/reference/types.forAwait.esnext.3.symbols create mode 100644 tests/baselines/reference/types.forAwait.esnext.3.types create mode 100644 tests/baselines/reference/typesOnlyExternalModuleStillHasInstance.symbols create mode 100644 tests/baselines/reference/typesOnlyExternalModuleStillHasInstance.types create mode 100644 tests/baselines/reference/typesWithDuplicateTypeParameters.symbols create mode 100644 tests/baselines/reference/typesWithDuplicateTypeParameters.types create mode 100644 tests/baselines/reference/typesWithPrivateConstructor.symbols create mode 100644 tests/baselines/reference/typesWithPrivateConstructor.types create mode 100644 tests/baselines/reference/typesWithProtectedConstructor.symbols create mode 100644 tests/baselines/reference/typesWithProtectedConstructor.types create mode 100644 tests/baselines/reference/typesWithPublicConstructor.symbols create mode 100644 tests/baselines/reference/typesWithPublicConstructor.types create mode 100644 tests/baselines/reference/umd-errors.symbols create mode 100644 tests/baselines/reference/umd-errors.types create mode 100644 tests/baselines/reference/umd2.symbols create mode 100644 tests/baselines/reference/umd2.types create mode 100644 tests/baselines/reference/umd5.symbols create mode 100644 tests/baselines/reference/umd5.types create mode 100644 tests/baselines/reference/umdDependencyComment2.symbols create mode 100644 tests/baselines/reference/umdDependencyComment2.types create mode 100644 tests/baselines/reference/umdDependencyCommentName1.symbols create mode 100644 tests/baselines/reference/umdDependencyCommentName1.types create mode 100644 tests/baselines/reference/umdDependencyCommentName2.symbols create mode 100644 tests/baselines/reference/umdDependencyCommentName2.types create mode 100644 tests/baselines/reference/unaryOperators1.symbols create mode 100644 tests/baselines/reference/unaryOperators1.types create mode 100644 tests/baselines/reference/unaryOperatorsInStrictMode.symbols create mode 100644 tests/baselines/reference/unaryOperatorsInStrictMode.types create mode 100644 tests/baselines/reference/uncaughtCompilerError2.symbols create mode 100644 tests/baselines/reference/uncaughtCompilerError2.types create mode 100644 tests/baselines/reference/unclosedExportClause01.symbols create mode 100644 tests/baselines/reference/unclosedExportClause01.types create mode 100644 tests/baselines/reference/unclosedExportClause02.symbols create mode 100644 tests/baselines/reference/unclosedExportClause02.types create mode 100644 tests/baselines/reference/undeclaredBase.symbols create mode 100644 tests/baselines/reference/undeclaredBase.types create mode 100644 tests/baselines/reference/undeclaredMethod.symbols create mode 100644 tests/baselines/reference/undeclaredMethod.types create mode 100644 tests/baselines/reference/undeclaredModuleError.symbols create mode 100644 tests/baselines/reference/undeclaredModuleError.types create mode 100644 tests/baselines/reference/undeclaredVarEmit.symbols create mode 100644 tests/baselines/reference/undeclaredVarEmit.types create mode 100644 tests/baselines/reference/undefinedSymbolReferencedInArrayLiteral1.symbols create mode 100644 tests/baselines/reference/undefinedSymbolReferencedInArrayLiteral1.types create mode 100644 tests/baselines/reference/undefinedTypeArgument1.symbols create mode 100644 tests/baselines/reference/undefinedTypeArgument1.types create mode 100644 tests/baselines/reference/undefinedTypeArgument2.symbols create mode 100644 tests/baselines/reference/undefinedTypeArgument2.types create mode 100644 tests/baselines/reference/undefinedTypeAssignment1.symbols create mode 100644 tests/baselines/reference/undefinedTypeAssignment1.types create mode 100644 tests/baselines/reference/undefinedTypeAssignment2.symbols create mode 100644 tests/baselines/reference/undefinedTypeAssignment2.types create mode 100644 tests/baselines/reference/undefinedTypeAssignment3.symbols create mode 100644 tests/baselines/reference/undefinedTypeAssignment3.types create mode 100644 tests/baselines/reference/undefinedTypeAssignment4.symbols create mode 100644 tests/baselines/reference/undefinedTypeAssignment4.types create mode 100644 tests/baselines/reference/underscoreThisInDerivedClass02.symbols create mode 100644 tests/baselines/reference/underscoreThisInDerivedClass02.types create mode 100644 tests/baselines/reference/unexpectedStatementBlockTerminator.symbols create mode 100644 tests/baselines/reference/unexpectedStatementBlockTerminator.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings07_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings07_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings07_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings07_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings12_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings12_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings12_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings12_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings14_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings14_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings14_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings14_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings17_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings17_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings17_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings17_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings19_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings19_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings19_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings19_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings20_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings20_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings20_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings20_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings21_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings21_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings21_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings21_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings22_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings22_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings22_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings22_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings24_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings24_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings24_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings24_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings25_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings25_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings25_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInStrings25_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates07_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates07_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates07_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates07_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates12_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates12_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates12_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates12_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates14_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates14_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates14_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates14_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates17_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates17_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates17_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates17_ES6.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates19_ES5.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates19_ES5.types create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates19_ES6.symbols create mode 100644 tests/baselines/reference/unicodeExtendedEscapesInTemplates19_ES6.types create mode 100644 tests/baselines/reference/unicodeIdentifierName2.symbols create mode 100644 tests/baselines/reference/unicodeIdentifierName2.types create mode 100644 tests/baselines/reference/unionPropertyExistence.symbols create mode 100644 tests/baselines/reference/unionPropertyExistence.types create mode 100644 tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.symbols create mode 100644 tests/baselines/reference/unionSubtypeIfEveryConstituentTypeIsSubtype.types create mode 100644 tests/baselines/reference/unionTypeCallSignatures.symbols create mode 100644 tests/baselines/reference/unionTypeCallSignatures.types create mode 100644 tests/baselines/reference/unionTypeCallSignatures4.symbols create mode 100644 tests/baselines/reference/unionTypeCallSignatures4.types create mode 100644 tests/baselines/reference/unionTypeConstructSignatures.symbols create mode 100644 tests/baselines/reference/unionTypeConstructSignatures.types create mode 100644 tests/baselines/reference/unionTypeEquivalence.symbols create mode 100644 tests/baselines/reference/unionTypeEquivalence.types create mode 100644 tests/baselines/reference/unionTypeIdentity.symbols create mode 100644 tests/baselines/reference/unionTypeIdentity.types create mode 100644 tests/baselines/reference/unionTypeLiterals.symbols create mode 100644 tests/baselines/reference/unionTypeLiterals.types create mode 100644 tests/baselines/reference/unionTypeMembers.symbols create mode 100644 tests/baselines/reference/unionTypeMembers.types create mode 100644 tests/baselines/reference/unionTypePropertyAccessibility.symbols create mode 100644 tests/baselines/reference/unionTypePropertyAccessibility.types create mode 100644 tests/baselines/reference/unionTypeReadonly.symbols create mode 100644 tests/baselines/reference/unionTypeReadonly.types create mode 100644 tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction2.symbols create mode 100644 tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction2.types create mode 100644 tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction3.symbols create mode 100644 tests/baselines/reference/unionTypeWithRecursiveSubtypeReduction3.types create mode 100644 tests/baselines/reference/unionTypesAssignability.symbols create mode 100644 tests/baselines/reference/unionTypesAssignability.types create mode 100644 tests/baselines/reference/unknownSymbolInGenericReturnType.symbols create mode 100644 tests/baselines/reference/unknownSymbolInGenericReturnType.types create mode 100644 tests/baselines/reference/unknownSymbolOffContextualType1.symbols create mode 100644 tests/baselines/reference/unknownSymbolOffContextualType1.types create mode 100644 tests/baselines/reference/unknownSymbols1.symbols create mode 100644 tests/baselines/reference/unknownSymbols1.types create mode 100644 tests/baselines/reference/unknownSymbols2.symbols create mode 100644 tests/baselines/reference/unknownSymbols2.types create mode 100644 tests/baselines/reference/unknownTypeArgOnCall.symbols create mode 100644 tests/baselines/reference/unknownTypeArgOnCall.types create mode 100644 tests/baselines/reference/unknownTypeErrors.symbols create mode 100644 tests/baselines/reference/unknownTypeErrors.types create mode 100644 tests/baselines/reference/unqualifiedCallToClassStatic1.symbols create mode 100644 tests/baselines/reference/unqualifiedCallToClassStatic1.types create mode 100644 tests/baselines/reference/unreachableJavascriptChecked.symbols create mode 100644 tests/baselines/reference/unreachableJavascriptChecked.types create mode 100644 tests/baselines/reference/unresolvedTypeAssertionSymbol.symbols create mode 100644 tests/baselines/reference/unresolvedTypeAssertionSymbol.types create mode 100644 tests/baselines/reference/unspecializedConstraints.symbols create mode 100644 tests/baselines/reference/unspecializedConstraints.types create mode 100644 tests/baselines/reference/unterminatedRegexAtEndOfSource1.symbols create mode 100644 tests/baselines/reference/unterminatedRegexAtEndOfSource1.types create mode 100644 tests/baselines/reference/unterminatedStringLiteralWithBackslash1.symbols create mode 100644 tests/baselines/reference/unterminatedStringLiteralWithBackslash1.types create mode 100644 tests/baselines/reference/untypedFunctionCallsWithTypeParameters1.symbols create mode 100644 tests/baselines/reference/untypedFunctionCallsWithTypeParameters1.types create mode 100644 tests/baselines/reference/untypedModuleImport_noImplicitAny.symbols create mode 100644 tests/baselines/reference/untypedModuleImport_noImplicitAny.types create mode 100644 tests/baselines/reference/untypedModuleImport_withAugmentation.symbols create mode 100644 tests/baselines/reference/untypedModuleImport_withAugmentation.types create mode 100644 tests/baselines/reference/untypedModuleImport_withAugmentation2.symbols create mode 100644 tests/baselines/reference/untypedModuleImport_withAugmentation2.types create mode 100644 tests/baselines/reference/unusedClassesinModule1.symbols create mode 100644 tests/baselines/reference/unusedClassesinModule1.types create mode 100644 tests/baselines/reference/unusedClassesinNamespace1.symbols create mode 100644 tests/baselines/reference/unusedClassesinNamespace1.types create mode 100644 tests/baselines/reference/unusedClassesinNamespace2.symbols create mode 100644 tests/baselines/reference/unusedClassesinNamespace2.types create mode 100644 tests/baselines/reference/unusedClassesinNamespace4.symbols create mode 100644 tests/baselines/reference/unusedClassesinNamespace4.types create mode 100644 tests/baselines/reference/unusedClassesinNamespace5.symbols create mode 100644 tests/baselines/reference/unusedClassesinNamespace5.types create mode 100644 tests/baselines/reference/unusedDestructuringParameters.symbols create mode 100644 tests/baselines/reference/unusedDestructuringParameters.types create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces1.symbols create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces1.types create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces2.symbols create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces2.types create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces3.symbols create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces3.types create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces4.symbols create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces4.types create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces5.symbols create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces5.types create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces6.symbols create mode 100644 tests/baselines/reference/unusedFunctionsinNamespaces6.types create mode 100644 tests/baselines/reference/unusedIdentifiersConsolidated1.symbols create mode 100644 tests/baselines/reference/unusedIdentifiersConsolidated1.types create mode 100644 tests/baselines/reference/unusedImports1.symbols create mode 100644 tests/baselines/reference/unusedImports1.types create mode 100644 tests/baselines/reference/unusedImports10.symbols create mode 100644 tests/baselines/reference/unusedImports10.types create mode 100644 tests/baselines/reference/unusedImports12.symbols create mode 100644 tests/baselines/reference/unusedImports12.types create mode 100644 tests/baselines/reference/unusedImports2.symbols create mode 100644 tests/baselines/reference/unusedImports2.types create mode 100644 tests/baselines/reference/unusedImports3.symbols create mode 100644 tests/baselines/reference/unusedImports3.types create mode 100644 tests/baselines/reference/unusedImports4.symbols create mode 100644 tests/baselines/reference/unusedImports4.types create mode 100644 tests/baselines/reference/unusedImports5.symbols create mode 100644 tests/baselines/reference/unusedImports5.types create mode 100644 tests/baselines/reference/unusedImports6.symbols create mode 100644 tests/baselines/reference/unusedImports6.types create mode 100644 tests/baselines/reference/unusedImports7.symbols create mode 100644 tests/baselines/reference/unusedImports7.types create mode 100644 tests/baselines/reference/unusedImports8.symbols create mode 100644 tests/baselines/reference/unusedImports8.types create mode 100644 tests/baselines/reference/unusedImports9.symbols create mode 100644 tests/baselines/reference/unusedImports9.types create mode 100644 tests/baselines/reference/unusedInterfaceinNamespace1.symbols create mode 100644 tests/baselines/reference/unusedInterfaceinNamespace1.types create mode 100644 tests/baselines/reference/unusedInterfaceinNamespace2.symbols create mode 100644 tests/baselines/reference/unusedInterfaceinNamespace2.types create mode 100644 tests/baselines/reference/unusedInterfaceinNamespace3.symbols create mode 100644 tests/baselines/reference/unusedInterfaceinNamespace3.types create mode 100644 tests/baselines/reference/unusedInvalidTypeArguments.symbols create mode 100644 tests/baselines/reference/unusedInvalidTypeArguments.types create mode 100644 tests/baselines/reference/unusedLocalsAndObjectSpread.symbols create mode 100644 tests/baselines/reference/unusedLocalsAndObjectSpread.types create mode 100644 tests/baselines/reference/unusedLocalsAndObjectSpread2.symbols create mode 100644 tests/baselines/reference/unusedLocalsAndObjectSpread2.types create mode 100644 tests/baselines/reference/unusedLocalsAndParameters.symbols create mode 100644 tests/baselines/reference/unusedLocalsAndParameters.types create mode 100644 tests/baselines/reference/unusedLocalsAndParametersDeferred.symbols create mode 100644 tests/baselines/reference/unusedLocalsAndParametersDeferred.types create mode 100644 tests/baselines/reference/unusedLocalsAndParametersTypeAliases2.symbols create mode 100644 tests/baselines/reference/unusedLocalsAndParametersTypeAliases2.types create mode 100644 tests/baselines/reference/unusedLocalsInMethod1.symbols create mode 100644 tests/baselines/reference/unusedLocalsInMethod1.types create mode 100644 tests/baselines/reference/unusedLocalsInMethod2.symbols create mode 100644 tests/baselines/reference/unusedLocalsInMethod2.types create mode 100644 tests/baselines/reference/unusedLocalsInMethod3.symbols create mode 100644 tests/baselines/reference/unusedLocalsInMethod3.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration1.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration2.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionDeclaration2.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionExpression1.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionExpression1.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionExpression2.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionDeclarationWithinFunctionExpression2.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionDeclaration1.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionDeclaration1.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionDeclaration2.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionDeclaration2.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionExpression1.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionExpression1.types create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionExpression2.symbols create mode 100644 tests/baselines/reference/unusedLocalsOnFunctionExpressionWithinFunctionExpression2.types create mode 100644 tests/baselines/reference/unusedLocalsStartingWithUnderscore.symbols create mode 100644 tests/baselines/reference/unusedLocalsStartingWithUnderscore.types create mode 100644 tests/baselines/reference/unusedLocalsinConstructor1.symbols create mode 100644 tests/baselines/reference/unusedLocalsinConstructor1.types create mode 100644 tests/baselines/reference/unusedLocalsinConstructor2.symbols create mode 100644 tests/baselines/reference/unusedLocalsinConstructor2.types create mode 100644 tests/baselines/reference/unusedModuleInModule.symbols create mode 100644 tests/baselines/reference/unusedModuleInModule.types create mode 100644 tests/baselines/reference/unusedMultipleParameter1InContructor.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameter1InContructor.types create mode 100644 tests/baselines/reference/unusedMultipleParameter1InFunctionExpression.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameter1InFunctionExpression.types create mode 100644 tests/baselines/reference/unusedMultipleParameter2InContructor.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameter2InContructor.types create mode 100644 tests/baselines/reference/unusedMultipleParameter2InFunctionExpression.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameter2InFunctionExpression.types create mode 100644 tests/baselines/reference/unusedMultipleParameters1InFunctionDeclaration.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameters1InFunctionDeclaration.types create mode 100644 tests/baselines/reference/unusedMultipleParameters1InMethodDeclaration.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameters1InMethodDeclaration.types create mode 100644 tests/baselines/reference/unusedMultipleParameters2InFunctionDeclaration.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameters2InFunctionDeclaration.types create mode 100644 tests/baselines/reference/unusedMultipleParameters2InMethodDeclaration.symbols create mode 100644 tests/baselines/reference/unusedMultipleParameters2InMethodDeclaration.types create mode 100644 tests/baselines/reference/unusedNamespaceInModule.symbols create mode 100644 tests/baselines/reference/unusedNamespaceInModule.types create mode 100644 tests/baselines/reference/unusedNamespaceInNamespace.symbols create mode 100644 tests/baselines/reference/unusedNamespaceInNamespace.types create mode 100644 tests/baselines/reference/unusedParameterProperty1.symbols create mode 100644 tests/baselines/reference/unusedParameterProperty1.types create mode 100644 tests/baselines/reference/unusedParameterProperty2.symbols create mode 100644 tests/baselines/reference/unusedParameterProperty2.types create mode 100644 tests/baselines/reference/unusedParametersInLambda1.symbols create mode 100644 tests/baselines/reference/unusedParametersInLambda1.types create mode 100644 tests/baselines/reference/unusedParametersInLambda2.symbols create mode 100644 tests/baselines/reference/unusedParametersInLambda2.types create mode 100644 tests/baselines/reference/unusedParametersWithUnderscore.symbols create mode 100644 tests/baselines/reference/unusedParametersWithUnderscore.types create mode 100644 tests/baselines/reference/unusedParametersinConstructor1.symbols create mode 100644 tests/baselines/reference/unusedParametersinConstructor1.types create mode 100644 tests/baselines/reference/unusedParametersinConstructor2.symbols create mode 100644 tests/baselines/reference/unusedParametersinConstructor2.types create mode 100644 tests/baselines/reference/unusedParametersinConstructor3.symbols create mode 100644 tests/baselines/reference/unusedParametersinConstructor3.types create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass1.symbols create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass1.types create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass2.symbols create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass2.types create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass3.symbols create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass3.types create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass4.symbols create mode 100644 tests/baselines/reference/unusedPrivateMethodInClass4.types create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass1.symbols create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass1.types create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass2.symbols create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass2.types create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass3.symbols create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass3.types create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass4.symbols create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass4.types create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass5.symbols create mode 100644 tests/baselines/reference/unusedPrivateVariableInClass5.types create mode 100644 tests/baselines/reference/unusedSingleParameterInContructor.symbols create mode 100644 tests/baselines/reference/unusedSingleParameterInContructor.types create mode 100644 tests/baselines/reference/unusedSingleParameterInFunctionDeclaration.symbols create mode 100644 tests/baselines/reference/unusedSingleParameterInFunctionDeclaration.types create mode 100644 tests/baselines/reference/unusedSingleParameterInFunctionExpression.symbols create mode 100644 tests/baselines/reference/unusedSingleParameterInFunctionExpression.types create mode 100644 tests/baselines/reference/unusedSingleParameterInMethodDeclaration.symbols create mode 100644 tests/baselines/reference/unusedSingleParameterInMethodDeclaration.types create mode 100644 tests/baselines/reference/unusedSwitchStatment.symbols create mode 100644 tests/baselines/reference/unusedSwitchStatment.types create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction1.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction1.types create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction2.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction2.types create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction3.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction3.types create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction4.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInFunction4.types create mode 100644 tests/baselines/reference/unusedTypeParameterInInterface1.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInInterface1.types create mode 100644 tests/baselines/reference/unusedTypeParameterInInterface2.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInInterface2.types create mode 100644 tests/baselines/reference/unusedTypeParameterInLambda1.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInLambda1.types create mode 100644 tests/baselines/reference/unusedTypeParameterInLambda2.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInLambda2.types create mode 100644 tests/baselines/reference/unusedTypeParameterInLambda3.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInLambda3.types create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod1.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod1.types create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod2.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod2.types create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod3.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod3.types create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod4.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod4.types create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod5.symbols create mode 100644 tests/baselines/reference/unusedTypeParameterInMethod5.types create mode 100644 tests/baselines/reference/unusedTypeParameters1.symbols create mode 100644 tests/baselines/reference/unusedTypeParameters1.types create mode 100644 tests/baselines/reference/unusedTypeParameters10.symbols create mode 100644 tests/baselines/reference/unusedTypeParameters10.types create mode 100644 tests/baselines/reference/unusedTypeParameters2.symbols create mode 100644 tests/baselines/reference/unusedTypeParameters2.types create mode 100644 tests/baselines/reference/unusedTypeParameters3.symbols create mode 100644 tests/baselines/reference/unusedTypeParameters3.types create mode 100644 tests/baselines/reference/unusedTypeParameters4.symbols create mode 100644 tests/baselines/reference/unusedTypeParameters4.types create mode 100644 tests/baselines/reference/unusedTypeParameters5.symbols create mode 100644 tests/baselines/reference/unusedTypeParameters5.types create mode 100644 tests/baselines/reference/unusedTypeParameters8.symbols create mode 100644 tests/baselines/reference/unusedTypeParameters8.types create mode 100644 tests/baselines/reference/unusedTypeParametersWithUnderscore.symbols create mode 100644 tests/baselines/reference/unusedTypeParametersWithUnderscore.types create mode 100644 tests/baselines/reference/unusedVariablesinBlocks1.symbols create mode 100644 tests/baselines/reference/unusedVariablesinBlocks1.types create mode 100644 tests/baselines/reference/unusedVariablesinBlocks2.symbols create mode 100644 tests/baselines/reference/unusedVariablesinBlocks2.types create mode 100644 tests/baselines/reference/unusedVariablesinForLoop.symbols create mode 100644 tests/baselines/reference/unusedVariablesinForLoop.types create mode 100644 tests/baselines/reference/unusedVariablesinForLoop2.symbols create mode 100644 tests/baselines/reference/unusedVariablesinForLoop2.types create mode 100644 tests/baselines/reference/unusedVariablesinForLoop3.symbols create mode 100644 tests/baselines/reference/unusedVariablesinForLoop3.types create mode 100644 tests/baselines/reference/unusedVariablesinForLoop4.symbols create mode 100644 tests/baselines/reference/unusedVariablesinForLoop4.types create mode 100644 tests/baselines/reference/unusedVariablesinModules1.symbols create mode 100644 tests/baselines/reference/unusedVariablesinModules1.types create mode 100644 tests/baselines/reference/unusedVariablesinNamespaces1.symbols create mode 100644 tests/baselines/reference/unusedVariablesinNamespaces1.types create mode 100644 tests/baselines/reference/unusedVariablesinNamespaces2.symbols create mode 100644 tests/baselines/reference/unusedVariablesinNamespaces2.types create mode 100644 tests/baselines/reference/unusedVariablesinNamespaces3.symbols create mode 100644 tests/baselines/reference/unusedVariablesinNamespaces3.types create mode 100644 tests/baselines/reference/useBeforeDeclaration_propertyAssignment.symbols create mode 100644 tests/baselines/reference/useBeforeDeclaration_propertyAssignment.types create mode 100644 tests/baselines/reference/useBeforeDeclaration_superClass.symbols create mode 100644 tests/baselines/reference/useBeforeDeclaration_superClass.types create mode 100644 tests/baselines/reference/useObjectValuesAndEntries2.symbols create mode 100644 tests/baselines/reference/useObjectValuesAndEntries2.types create mode 100644 tests/baselines/reference/useObjectValuesAndEntries3.symbols create mode 100644 tests/baselines/reference/useObjectValuesAndEntries3.types create mode 100644 tests/baselines/reference/useSharedArrayBuffer2.symbols create mode 100644 tests/baselines/reference/useSharedArrayBuffer2.types create mode 100644 tests/baselines/reference/useSharedArrayBuffer3.symbols create mode 100644 tests/baselines/reference/useSharedArrayBuffer3.types create mode 100644 tests/baselines/reference/validMultipleVariableDeclarations.symbols create mode 100644 tests/baselines/reference/validMultipleVariableDeclarations.types create mode 100644 tests/baselines/reference/validNullAssignments.symbols create mode 100644 tests/baselines/reference/validNullAssignments.types create mode 100644 tests/baselines/reference/validRegexp.symbols create mode 100644 tests/baselines/reference/validRegexp.types create mode 100644 tests/baselines/reference/varAndFunctionShareName.symbols create mode 100644 tests/baselines/reference/varAndFunctionShareName.types create mode 100644 tests/baselines/reference/varArgConstructorMemberParameter.symbols create mode 100644 tests/baselines/reference/varArgConstructorMemberParameter.types create mode 100644 tests/baselines/reference/varArgWithNoParamName.symbols create mode 100644 tests/baselines/reference/varArgWithNoParamName.types create mode 100644 tests/baselines/reference/varBlock.symbols create mode 100644 tests/baselines/reference/varBlock.types create mode 100644 tests/baselines/reference/varNameConflictsWithImportInDifferentPartOfModule.symbols create mode 100644 tests/baselines/reference/varNameConflictsWithImportInDifferentPartOfModule.types create mode 100644 tests/baselines/reference/vararg.symbols create mode 100644 tests/baselines/reference/vararg.types create mode 100644 tests/baselines/reference/variableDeclarationInStrictMode1.symbols create mode 100644 tests/baselines/reference/variableDeclarationInStrictMode1.types create mode 100644 tests/baselines/reference/variableDeclaratorResolvedDuringContextualTyping.symbols create mode 100644 tests/baselines/reference/variableDeclaratorResolvedDuringContextualTyping.types create mode 100644 tests/baselines/reference/voidArrayLit.symbols create mode 100644 tests/baselines/reference/voidArrayLit.types create mode 100644 tests/baselines/reference/voidAsNonAmbiguousReturnType.symbols create mode 100644 tests/baselines/reference/voidAsNonAmbiguousReturnType.types create mode 100644 tests/baselines/reference/voidOperatorInvalidOperations.symbols create mode 100644 tests/baselines/reference/voidOperatorInvalidOperations.types create mode 100644 tests/baselines/reference/voidOperatorWithAnyOtherType.symbols create mode 100644 tests/baselines/reference/voidOperatorWithAnyOtherType.types create mode 100644 tests/baselines/reference/weakType.symbols create mode 100644 tests/baselines/reference/weakType.types create mode 100644 tests/baselines/reference/whileContinueStatements.symbols create mode 100644 tests/baselines/reference/whileContinueStatements.types create mode 100644 tests/baselines/reference/widenToAny1.symbols create mode 100644 tests/baselines/reference/widenToAny1.types create mode 100644 tests/baselines/reference/widenToAny2.symbols create mode 100644 tests/baselines/reference/widenToAny2.types create mode 100644 tests/baselines/reference/widenedTypes.symbols create mode 100644 tests/baselines/reference/widenedTypes.types create mode 100644 tests/baselines/reference/wideningTuples3.symbols create mode 100644 tests/baselines/reference/wideningTuples3.types create mode 100644 tests/baselines/reference/wideningTuples5.symbols create mode 100644 tests/baselines/reference/wideningTuples5.types create mode 100644 tests/baselines/reference/wideningTuples7.symbols create mode 100644 tests/baselines/reference/wideningTuples7.types create mode 100644 tests/baselines/reference/withStatement.symbols create mode 100644 tests/baselines/reference/withStatement.types create mode 100644 tests/baselines/reference/withStatementErrors.symbols create mode 100644 tests/baselines/reference/withStatementErrors.types create mode 100644 tests/baselines/reference/withStatementNestedScope.symbols create mode 100644 tests/baselines/reference/withStatementNestedScope.types create mode 100644 tests/baselines/reference/withStatements.symbols create mode 100644 tests/baselines/reference/withStatements.types create mode 100644 tests/baselines/reference/witness.symbols create mode 100644 tests/baselines/reference/witness.types create mode 100644 tests/baselines/reference/wrappedAndRecursiveConstraints4.symbols create mode 100644 tests/baselines/reference/wrappedAndRecursiveConstraints4.types create mode 100644 tests/baselines/reference/wrappedRecursiveGenericType.symbols create mode 100644 tests/baselines/reference/wrappedRecursiveGenericType.types create mode 100644 tests/baselines/reference/yieldStringLiteral.symbols create mode 100644 tests/baselines/reference/yieldStringLiteral.types diff --git a/.gitignore b/.gitignore index 8c83d319ed7..0b29eebf521 100644 --- a/.gitignore +++ b/.gitignore @@ -59,4 +59,4 @@ internal/ .idea yarn.lock package-lock.json -.parallelperf.json +.parallelperf.* diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 97e60777159..70141c853ca 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1456,11 +1456,6 @@ namespace ts { } function declareSymbolAndAddToSymbolTable(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol { - // Just call this directly so that the return type of this function stays "void". - return declareSymbolAndAddToSymbolTableWorker(node, symbolFlags, symbolExcludes); - } - - function declareSymbolAndAddToSymbolTableWorker(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol { switch (container.kind) { // Modules, source files, and classes need specialized handling for how their // members are declared (for example, a member of a class will go into a specific @@ -1683,6 +1678,9 @@ namespace ts { function bindAnonymousDeclaration(node: Declaration, symbolFlags: SymbolFlags, name: __String) { const symbol = createSymbol(symbolFlags, name); + if (symbolFlags & SymbolFlags.EnumMember) { + symbol.parent = container.symbol; + } addDeclarationToSymbol(symbol, node, symbolFlags); } diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts index dc3aa64c6ac..79695639fd8 100644 --- a/src/harness/compilerRunner.ts +++ b/src/harness/compilerRunner.ts @@ -177,7 +177,7 @@ class CompilerBaselineRunner extends RunnerBase { return; } - Harness.Compiler.doTypeAndSymbolBaseline(justName, result, toBeCompiled.concat(otherFiles).filter(file => !!result.program.getSourceFile(file.unitName))); + Harness.Compiler.doTypeAndSymbolBaseline(justName, result.program, toBeCompiled.concat(otherFiles).filter(file => !!result.program.getSourceFile(file.unitName))); }); }); } diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 88d32871c68..a5671b832e9 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -148,6 +148,8 @@ namespace Utils { }); } + export const canonicalizeForHarness = ts.createGetCanonicalFileName(/*caseSensitive*/ false); // This is done so tests work on windows _and_ linux + export function assertInvariants(node: ts.Node, parent: ts.Node): void { if (node) { assert.isFalse(node.pos < 0, "node.pos < 0"); @@ -1446,10 +1448,7 @@ namespace Harness { }); } - export function doTypeAndSymbolBaseline(baselinePath: string, result: CompilerResult, allFiles: {unitName: string, content: string}[], opts?: Harness.Baseline.BaselineOptions, multifile?: boolean) { - if (result.errors.length !== 0) { - return; - } + export function doTypeAndSymbolBaseline(baselinePath: string, program: ts.Program, allFiles: {unitName: string, content: string}[], opts?: Harness.Baseline.BaselineOptions, multifile?: boolean, skipTypeAndSymbolbaselines?: boolean) { // The full walker simulates the types that you would get from doing a full // compile. The pull walker simulates the types you get when you just do // a type query for a random node (like how the LS would do it). Most of the @@ -1465,16 +1464,8 @@ namespace Harness { // These types are equivalent, but depend on what order the compiler observed // certain parts of the program. - const program = result.program; - const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true); - const fullResults = ts.createMap(); - - for (const sourceFile of allFiles) { - fullResults.set(sourceFile.unitName, fullWalker.getTypeAndSymbols(sourceFile.unitName)); - } - // Produce baselines. The first gives the types for all expressions. // The second gives symbols for all identifiers. let typesError: Error, symbolsError: Error; @@ -1515,76 +1506,77 @@ namespace Harness { baselinePath.replace(/\.tsx?/, "") : baselinePath; if (!multifile) { - const fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine); + const fullBaseLine = generateBaseLine(isSymbolBaseLine, skipTypeAndSymbolbaselines); Harness.Baseline.runBaseline(outputFileName + fullExtension, () => fullBaseLine, opts); } else { Harness.Baseline.runMultifileBaseline(outputFileName, fullExtension, () => { - return iterateBaseLine(fullResults, isSymbolBaseLine); + return iterateBaseLine(isSymbolBaseLine, skipTypeAndSymbolbaselines); }, opts); } } - function generateBaseLine(typeWriterResults: ts.Map, isSymbolBaseline: boolean): string { + function generateBaseLine(isSymbolBaseline: boolean, skipTypeAndSymbolbaselines?: boolean): string { let result = ""; - const gen = iterateBaseLine(typeWriterResults, isSymbolBaseline); + const gen = iterateBaseLine(isSymbolBaseline, skipTypeAndSymbolbaselines); for (let {done, value} = gen.next(); !done; { done, value } = gen.next()) { const [, content] = value; result += content; } - return result; + /* tslint:disable:no-null-keyword */ + return result || null; + /* tslint:enable:no-null-keyword */ } - function *iterateBaseLine(typeWriterResults: ts.Map, isSymbolBaseline: boolean): IterableIterator<[string, string]> { - let typeLines = ""; - const typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {}; + function *iterateBaseLine(isSymbolBaseline: boolean, skipTypeAndSymbolbaselines?: boolean): IterableIterator<[string, string]> { + if (skipTypeAndSymbolbaselines) { + return; + } const dupeCase = ts.createMap(); for (const file of allFiles) { - const codeLines = file.content.split("\n"); - const key = file.unitName; - typeWriterResults.get(file.unitName).forEach(result => { + const { unitName } = file; + let typeLines = "=== " + unitName + " ===\r\n"; + const codeLines = ts.flatMap(file.content.split(/\r?\n/g), e => e.split(/[\r\u2028\u2029]/g)); + const gen: IterableIterator = isSymbolBaseline ? fullWalker.getSymbols(unitName) : fullWalker.getTypes(unitName); + let lastIndexWritten: number | undefined; + for (let {done, value: result} = gen.next(); !done; { done, value: result } = gen.next()) { if (isSymbolBaseline && !result.symbol) { return; } - + if (lastIndexWritten === undefined) { + typeLines += codeLines.slice(0, result.line + 1).join("\r\n") + "\r\n"; + } + else if (result.line !== lastIndexWritten) { + if (!((lastIndexWritten + 1 < codeLines.length) && (codeLines[lastIndexWritten + 1].match(/^\s*[{|}]\s*$/) || codeLines[lastIndexWritten + 1].trim() === ""))) { + typeLines += "\r\n"; + } + typeLines += codeLines.slice(lastIndexWritten + 1, result.line + 1).join("\r\n") + "\r\n"; + } + lastIndexWritten = result.line; const typeOrSymbolString = isSymbolBaseline ? result.symbol : result.type; const formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + typeOrSymbolString; - if (!typeMap[key]) { - typeMap[key] = {}; - } + typeLines += ">" + formattedLine + "\r\n"; + } - let typeInfo = [formattedLine]; - const existingTypeInfo = typeMap[key][result.line]; - if (existingTypeInfo) { - typeInfo = existingTypeInfo.concat(typeInfo); - } - typeMap[key][result.line] = typeInfo; - }); - - typeLines += "=== " + file.unitName + " ===\r\n"; - for (let i = 0; i < codeLines.length; i++) { - const currentCodeLine = codeLines[i]; - typeLines += currentCodeLine + "\r\n"; - if (typeMap[key]) { - const typeInfo = typeMap[key][i]; - if (typeInfo) { - typeInfo.forEach(ty => { - typeLines += ">" + ty + "\r\n"; - }); - if (i + 1 < codeLines.length && (codeLines[i + 1].match(/^\s*[{|}]\s*$/) || codeLines[i + 1].trim() === "")) { - } - else { - typeLines += "\r\n"; - } - } - } - else { + // Preserve legacy behavior + if (lastIndexWritten === undefined) { + for (let i = 0; i < codeLines.length; i++) { + const currentCodeLine = codeLines[i]; + typeLines += currentCodeLine + "\r\n"; typeLines += "No type information for this code."; } } - yield [checkDuplicatedFileName(file.unitName, dupeCase), typeLines]; - typeLines = ""; + else { + if (lastIndexWritten + 1 < codeLines.length) { + if (!((lastIndexWritten + 1 < codeLines.length) && (codeLines[lastIndexWritten + 1].match(/^\s*[{|}]\s*$/) || codeLines[lastIndexWritten + 1].trim() === ""))) { + typeLines += "\r\n"; + } + typeLines += codeLines.slice(lastIndexWritten + 1).join("\r\n"); + } + typeLines += "\r\n"; + } + yield [checkDuplicatedFileName(unitName, dupeCase), typeLines]; } } } @@ -1726,7 +1718,7 @@ namespace Harness { } function sanitizeTestFilePath(name: string) { - return ts.normalizeSlashes(name.replace(/[\^<>:"|?*%]/g, "_")).replace(/\.\.\//g, "__dotdot/").toLowerCase(); + return ts.toPath(ts.normalizeSlashes(name.replace(/[\^<>:"|?*%]/g, "_")).replace(/\.\.\//g, "__dotdot/"), "", Utils.canonicalizeForHarness); } // This does not need to exist strictly speaking, but many tests will need to be updated if it's removed @@ -2070,7 +2062,6 @@ namespace Harness { export function runMultifileBaseline(relativeFileBase: string, extension: string, generateContent: () => IterableIterator<[string, string, number]> | IterableIterator<[string, string]>, opts?: BaselineOptions, referencedExtensions?: string[]): void { const gen = generateContent(); const writtenFiles = ts.createMap(); - const canonicalize = ts.createGetCanonicalFileName(/*caseSensitive*/ false); // This is done so tests work on windows _and_ linux /* tslint:disable-next-line:no-null-keyword */ const errors: Error[] = []; if (gen !== null) { @@ -2086,8 +2077,7 @@ namespace Harness { catch (e) { errors.push(e); } - const path = ts.toPath(relativeFileName, "", canonicalize); - writtenFiles.set(path, true); + writtenFiles.set(relativeFileName, true); } } @@ -2100,8 +2090,7 @@ namespace Harness { const missing: string[] = []; for (const name of existing) { const localCopy = name.substring(referenceDir.length - relativeFileBase.length); - const path = ts.toPath(localCopy, "", canonicalize); - if (!writtenFiles.has(path)) { + if (!writtenFiles.has(localCopy)) { missing.push(localCopy); } } @@ -2114,13 +2103,14 @@ namespace Harness { if (errors.length || missing.length) { let errorMsg = ""; if (errors.length) { - errorMsg += `The baseline for ${relativeFileBase} has changed:${"\n " + errors.map(e => e.message).join("\n ")}`; + errorMsg += `The baseline for ${relativeFileBase} in ${errors.length} files has changed:${"\n " + errors.slice(0, 5).map(e => e.message).join("\n ") + (errors.length > 5 ? "\n" + ` and ${errors.length - 5} more` : "")}`; } if (errors.length && missing.length) { errorMsg += "\n"; } if (missing.length) { - errorMsg += `Baseline missing files:${"\n " + missing.join("\n ") + "\n"}Written:${"\n " + ts.arrayFrom(writtenFiles.keys()).join("\n ")}`; + const writtenFilesArray = ts.arrayFrom(writtenFiles.keys()); + errorMsg += `Baseline missing ${missing.length} files:${"\n " + missing.slice(0, 5).join("\n ") + (missing.length > 5 ? "\n" + ` and ${missing.length - 5} more` : "") + "\n"}Written ${writtenFiles.size} files:${"\n " + writtenFilesArray.slice(0, 5).join("\n ") + (writtenFilesArray.length > 5 ? "\n" + ` and ${writtenFilesArray.length - 5} more` : "")}`; } throw new Error(errorMsg); } diff --git a/src/harness/parallel/host.ts b/src/harness/parallel/host.ts index 764e7635668..8380aaf97d1 100644 --- a/src/harness/parallel/host.ts +++ b/src/harness/parallel/host.ts @@ -26,9 +26,12 @@ namespace Harness.Parallel.Host { text?: string; } - const perfdataFileName = ".parallelperf.json"; - function readSavedPerfData(): {[testHash: string]: number} { - const perfDataContents = Harness.IO.readFile(perfdataFileName); + const perfdataFileNameFragment = ".parallelperf"; + function perfdataFileName(target?: string) { + return `${perfdataFileNameFragment}${target ? `.${target}` : ""}.json`; + } + function readSavedPerfData(target?: string): {[testHash: string]: number} { + const perfDataContents = Harness.IO.readFile(perfdataFileName(target)); if (perfDataContents) { return JSON.parse(perfDataContents); } @@ -46,7 +49,7 @@ namespace Harness.Parallel.Host { const { statSync }: { statSync(path: string): { size: number }; } = require("fs"); let tasks: { runner: TestRunnerKind, file: string, size: number }[] = []; const newTasks: { runner: TestRunnerKind, file: string, size: number }[] = []; - const perfData = readSavedPerfData(); + const perfData = readSavedPerfData(configOption); let totalCost = 0; let unknownValue: string | undefined; for (const runner of runners) { @@ -290,7 +293,7 @@ namespace Harness.Parallel.Host { reporter.epilogue(); } - Harness.IO.writeFile(perfdataFileName, JSON.stringify(newPerfData, null, 4)); // tslint:disable-line:no-null-keyword + Harness.IO.writeFile(perfdataFileName(configOption), JSON.stringify(newPerfData, null, 4)); // tslint:disable-line:no-null-keyword process.exit(errorResults.length); } diff --git a/src/harness/runner.ts b/src/harness/runner.ts index 0b361e7fc9e..c1345f422c3 100644 --- a/src/harness/runner.ts +++ b/src/harness/runner.ts @@ -101,6 +101,7 @@ interface TaskSet { files: string[]; } +let configOption: string; function handleTestConfig() { if (testConfigContent !== "") { const testConfig = JSON.parse(testConfigContent); @@ -136,6 +137,13 @@ function handleTestConfig() { continue; } + if (!configOption) { + configOption = option; + } + else { + configOption += "+" + option; + } + switch (option) { case "compiler": runners.push(new CompilerBaselineRunner(CompilerTestType.Conformance)); diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts index 1f398118c06..fc0c9178c20 100644 --- a/src/harness/rwcRunner.ts +++ b/src/harness/rwcRunner.ts @@ -39,6 +39,8 @@ namespace RWC { const baseName = /(.*)\/(.*).json/.exec(ts.normalizeSlashes(jsonPath))[2]; let currentDirectory: string; let useCustomLibraryFile: boolean; + let skipTypeAndSymbolbaselines = false; + const typeAndSymbolSizeLimit = 10000000; after(() => { // Mocha holds onto the closure environment of the describe callback even after the test is done. // Therefore we have to clean out large objects after the test is done. @@ -52,6 +54,7 @@ namespace RWC { // or to use lib.d.ts inside the json object. If the flag is true, use the lib.d.ts inside json file // otherwise use the lib.d.ts from built/local useCustomLibraryFile = undefined; + skipTypeAndSymbolbaselines = false; }); it("can compile", function(this: Mocha.ITestCallbackContext) { @@ -61,6 +64,7 @@ namespace RWC { const ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath)); currentDirectory = ioLog.currentDirectory; useCustomLibraryFile = ioLog.useCustomLibraryFile; + skipTypeAndSymbolbaselines = ioLog.filesRead.reduce((acc, elem) => (elem && elem.result && elem.result.contents) ? acc + elem.result.contents.length : acc, 0) > typeAndSymbolSizeLimit; runWithIOLog(ioLog, () => { opts = ts.parseCommandLine(ioLog.arguments, fileName => Harness.IO.readFile(fileName)); assert.equal(opts.errors.length, 0); @@ -217,10 +221,10 @@ namespace RWC { it("has the expected types", () => { // We don't need to pass the extension here because "doTypeAndSymbolBaseline" will append appropriate extension of ".types" or ".symbols" - Harness.Compiler.doTypeAndSymbolBaseline(baseName, compilerResult, inputFiles + Harness.Compiler.doTypeAndSymbolBaseline(baseName, compilerResult.program, inputFiles .concat(otherFiles) .filter(file => !!compilerResult.program.getSourceFile(file.unitName)) - .filter(e => !Harness.isDefaultLibraryFile(e.unitName)), baselineOpts, /*multifile*/ true); + .filter(e => !Harness.isDefaultLibraryFile(e.unitName)), baselineOpts, /*multifile*/ true, skipTypeAndSymbolbaselines); }); // Ideally, a generated declaration file will have no errors. But we allow generated diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts index 1e9316fa0ae..559d8ed332e 100644 --- a/src/harness/typeWriter.ts +++ b/src/harness/typeWriter.ts @@ -1,13 +1,26 @@ -interface TypeWriterResult { +interface TypeWriterTypeResult { line: number; syntaxKind: number; sourceText: string; type: string; +} + +interface TypeWriterSymbolResult { + line: number; + syntaxKind: number; + sourceText: string; symbol: string; } +interface TypeWriterResult { + line: number; + syntaxKind: number; + sourceText: string; + symbol?: string; + type?: string; +} + class TypeWriterWalker { - results: TypeWriterResult[]; currentSourceFile: ts.SourceFile; private checker: ts.TypeChecker; @@ -20,57 +33,93 @@ class TypeWriterWalker { : program.getTypeChecker(); } - public getTypeAndSymbols(fileName: string): TypeWriterResult[] { + public *getSymbols(fileName: string): IterableIterator { const sourceFile = this.program.getSourceFile(fileName); this.currentSourceFile = sourceFile; - this.results = []; - this.visitNode(sourceFile); - return this.results; + const gen = this.visitNode(sourceFile, /*isSymbolWalk*/ true); + for (let {done, value} = gen.next(); !done; { done, value } = gen.next()) { + yield value as TypeWriterSymbolResult; + } } - private visitNode(node: ts.Node): void { + public *getTypes(fileName: string): IterableIterator { + const sourceFile = this.program.getSourceFile(fileName); + this.currentSourceFile = sourceFile; + const gen = this.visitNode(sourceFile, /*isSymbolWalk*/ false); + for (let {done, value} = gen.next(); !done; { done, value } = gen.next()) { + yield value as TypeWriterTypeResult; + } + } + + private *visitNode(node: ts.Node, isSymbolWalk: boolean): IterableIterator { if (ts.isPartOfExpression(node) || node.kind === ts.SyntaxKind.Identifier) { - this.logTypeAndSymbol(node); + const result = this.writeTypeOrSymbol(node, isSymbolWalk); + if (result) { + yield result; + } } - ts.forEachChild(node, child => this.visitNode(child)); + const children: ts.Node[] = []; + ts.forEachChild(node, child => void children.push(child)); + for (const child of children) { + const gen = this.visitNode(child, isSymbolWalk); + for (let {done, value} = gen.next(); !done; { done, value } = gen.next()) { + yield value; + } + } } - private logTypeAndSymbol(node: ts.Node): void { + private writeTypeOrSymbol(node: ts.Node, isSymbolWalk: boolean): TypeWriterResult { const actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos); const lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos); const sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node); - // Workaround to ensure we output 'C' instead of 'typeof C' for base class expressions - // let type = this.checker.getTypeAtLocation(node); - const type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node); - ts.Debug.assert(type !== undefined, "type doesn't exist"); - const symbol = this.checker.getSymbolAtLocation(node); - - const typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation); - let symbolString: string; - if (symbol) { - symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent); - if (symbol.declarations) { - for (const declaration of symbol.declarations) { - symbolString += ", "; - const declSourceFile = declaration.getSourceFile(); - const declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos); - const fileName = ts.getBaseFileName(declSourceFile.fileName); - const isLibFile = /lib(.*)\.d\.ts/i.test(fileName); - symbolString += `Decl(${ fileName }, ${ isLibFile ? "--" : declLineAndCharacter.line }, ${ isLibFile ? "--" : declLineAndCharacter.character })`; - } - } - symbolString += ")"; + if (!isSymbolWalk) { + // Workaround to ensure we output 'C' instead of 'typeof C' for base class expressions + // let type = this.checker.getTypeAtLocation(node); + const type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node); + const typeString = type ? this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation) : "No type information available!"; + return { + line: lineAndCharacter.line, + syntaxKind: node.kind, + sourceText, + type: typeString + }; } - - this.results.push({ + const symbol = this.checker.getSymbolAtLocation(node); + if (!symbol) { + return; + } + let symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent); + if (symbol.declarations) { + let count = 0; + for (const declaration of symbol.declarations) { + if (count >= 5) { + symbolString += ` ... and ${symbol.declarations.length - count} more`; + break; + } + count++; + symbolString += ", "; + if ((declaration as any)["__symbolTestOutputCache"]) { + symbolString += (declaration as any)["__symbolTestOutputCache"]; + continue; + } + const declSourceFile = declaration.getSourceFile(); + const declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos); + const fileName = ts.getBaseFileName(declSourceFile.fileName); + const isLibFile = /lib(.*)\.d\.ts/i.test(fileName); + const declText = `Decl(${ fileName }, ${ isLibFile ? "--" : declLineAndCharacter.line }, ${ isLibFile ? "--" : declLineAndCharacter.character })`; + symbolString += declText; + (declaration as any)["__symbolTestOutputCache"] = declText; + } + } + symbolString += ")"; + return { line: lineAndCharacter.line, syntaxKind: node.kind, sourceText, - type: typeString, symbol: symbolString - }); + }; } } \ No newline at end of file diff --git a/tests/baselines/reference/ArrowFunction1.symbols b/tests/baselines/reference/ArrowFunction1.symbols new file mode 100644 index 00000000000..2c0b6a3e452 --- /dev/null +++ b/tests/baselines/reference/ArrowFunction1.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction1.ts === +var v = (a: ) => { +>v : Symbol(v, Decl(ArrowFunction1.ts, 0, 3)) +>a : Symbol(a, Decl(ArrowFunction1.ts, 0, 9)) + +}; diff --git a/tests/baselines/reference/ArrowFunction1.types b/tests/baselines/reference/ArrowFunction1.types new file mode 100644 index 00000000000..3f405bd7f36 --- /dev/null +++ b/tests/baselines/reference/ArrowFunction1.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction1.ts === +var v = (a: ) => { +>v : (a: any) => void +>(a: ) => { } : (a: any) => void +>a : any +> : No type information available! + +}; diff --git a/tests/baselines/reference/ArrowFunction3.symbols b/tests/baselines/reference/ArrowFunction3.symbols new file mode 100644 index 00000000000..825b7d54e1e --- /dev/null +++ b/tests/baselines/reference/ArrowFunction3.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction3.ts === +var v = (a): => { +>v : Symbol(v, Decl(ArrowFunction3.ts, 0, 3)) +>a : Symbol(a, Decl(ArrowFunction3.ts, 0, 9)) + +}; diff --git a/tests/baselines/reference/ArrowFunction3.types b/tests/baselines/reference/ArrowFunction3.types new file mode 100644 index 00000000000..64b46bd0d63 --- /dev/null +++ b/tests/baselines/reference/ArrowFunction3.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction3.ts === +var v = (a): => { +>v : (a: any) => any +>(a): => { } : (a: any) => any +>a : any +> : No type information available! + +}; diff --git a/tests/baselines/reference/ArrowFunctionExpression1.symbols b/tests/baselines/reference/ArrowFunctionExpression1.symbols new file mode 100644 index 00000000000..5fe82a1c15b --- /dev/null +++ b/tests/baselines/reference/ArrowFunctionExpression1.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/ArrowFunctionExpression1.ts === +var v = (public x: string) => { }; +>v : Symbol(v, Decl(ArrowFunctionExpression1.ts, 0, 3)) +>x : Symbol(x, Decl(ArrowFunctionExpression1.ts, 0, 9)) + diff --git a/tests/baselines/reference/ArrowFunctionExpression1.types b/tests/baselines/reference/ArrowFunctionExpression1.types new file mode 100644 index 00000000000..c62b1c198b1 --- /dev/null +++ b/tests/baselines/reference/ArrowFunctionExpression1.types @@ -0,0 +1,6 @@ +=== tests/cases/compiler/ArrowFunctionExpression1.ts === +var v = (public x: string) => { }; +>v : (public x: string) => void +>(public x: string) => { } : (public x: string) => void +>x : string + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.symbols new file mode 100644 index 00000000000..5c32f4eadce --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.symbols @@ -0,0 +1,97 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts === +// all expected to be errors + +class clodule1{ +>clodule1 : Symbol(clodule1, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 6, 1)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 2, 15)) + + id: string; +>id : Symbol(clodule1.id, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 2, 18)) + + value: T; +>value : Symbol(clodule1.value, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 4, 15)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 2, 15)) +} + +module clodule1 { +>clodule1 : Symbol(clodule1, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 6, 1)) + + function f(x: T) { } +>f : Symbol(f, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 8, 17)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 9, 15)) +} + +class clodule2{ +>clodule2 : Symbol(clodule2, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 10, 1), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 16, 1)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 12, 15)) + + id: string; +>id : Symbol(clodule2.id, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 12, 18)) + + value: T; +>value : Symbol(clodule2.value, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 14, 15)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 12, 15)) +} + +module clodule2 { +>clodule2 : Symbol(clodule2, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 10, 1), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 16, 1)) + + var x: T; +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 19, 7)) + + class D{ +>D : Symbol(D, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 19, 13)) +>U : Symbol(U, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 21, 12)) + + id: string; +>id : Symbol(D.id, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 21, 25)) + + value: U; +>value : Symbol(D.value, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 22, 19)) +>U : Symbol(U, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 21, 12)) + } +} + +class clodule3{ +>clodule3 : Symbol(clodule3, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 25, 1), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 31, 1)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 27, 15)) + + id: string; +>id : Symbol(clodule3.id, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 27, 18)) + + value: T; +>value : Symbol(clodule3.value, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 29, 15)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 27, 15)) +} + +module clodule3 { +>clodule3 : Symbol(clodule3, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 25, 1), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 31, 1)) + + export var y = { id: T }; +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 34, 14)) +>id : Symbol(id, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 34, 20)) +} + +class clodule4{ +>clodule4 : Symbol(clodule4, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 35, 1), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 41, 1)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 37, 15)) + + id: string; +>id : Symbol(clodule4.id, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 37, 18)) + + value: T; +>value : Symbol(clodule4.value, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 39, 15)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 37, 15)) +} + +module clodule4 { +>clodule4 : Symbol(clodule4, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 35, 1), Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 41, 1)) + + class D { +>D : Symbol(D, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 43, 17)) + + name: T; +>name : Symbol(D.name, Decl(ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts, 44, 13)) + } +} + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.types b/tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.types new file mode 100644 index 00000000000..5afcc735a92 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.types @@ -0,0 +1,103 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModuleMemberThatUsesClassTypeParameter.ts === +// all expected to be errors + +class clodule1{ +>clodule1 : clodule1 +>T : T + + id: string; +>id : string + + value: T; +>value : T +>T : T +} + +module clodule1 { +>clodule1 : typeof clodule1 + + function f(x: T) { } +>f : (x: any) => void +>x : any +>T : No type information available! +} + +class clodule2{ +>clodule2 : clodule2 +>T : T + + id: string; +>id : string + + value: T; +>value : T +>T : T +} + +module clodule2 { +>clodule2 : typeof clodule2 + + var x: T; +>x : any +>T : No type information available! + + class D{ +>D : D +>U : U +>T : No type information available! + + id: string; +>id : string + + value: U; +>value : U +>U : U + } +} + +class clodule3{ +>clodule3 : clodule3 +>T : T + + id: string; +>id : string + + value: T; +>value : T +>T : T +} + +module clodule3 { +>clodule3 : typeof clodule3 + + export var y = { id: T }; +>y : { id: any; } +>{ id: T } : { id: any; } +>id : any +>T : any +} + +class clodule4{ +>clodule4 : clodule4 +>T : T + + id: string; +>id : string + + value: T; +>value : T +>T : T +} + +module clodule4 { +>clodule4 : typeof clodule4 + + class D { +>D : D + + name: T; +>name : any +>T : No type information available! + } +} + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.symbols new file mode 100644 index 00000000000..a601fa9fedd --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.symbols @@ -0,0 +1,38 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts === +class clodule { +>clodule : Symbol(clodule, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 5, 1)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 0, 14)) + + id: string; +>id : Symbol(clodule.id, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 0, 18)) + + value: T; +>value : Symbol(clodule.value, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 1, 15)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 0, 14)) + + static fn(id: U) { } +>fn : Symbol(clodule.fn, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 2, 13)) +>U : Symbol(U, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 4, 14)) +>id : Symbol(id, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 4, 17)) +>U : Symbol(U, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 4, 14)) +} + +module clodule { +>clodule : Symbol(clodule, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 5, 1)) + + // error: duplicate identifier expected + export function fn(x: T, y: T): T { +>fn : Symbol(clodule.fn, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 7, 16)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 9, 26)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 9, 31)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) + + return x; +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts, 9, 26)) + } +} + + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.types b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.types new file mode 100644 index 00000000000..99a044d62c1 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.types @@ -0,0 +1,38 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.ts === +class clodule { +>clodule : clodule +>T : T + + id: string; +>id : string + + value: T; +>value : T +>T : T + + static fn(id: U) { } +>fn : (id: U) => void +>U : U +>id : U +>U : U +} + +module clodule { +>clodule : typeof clodule + + // error: duplicate identifier expected + export function fn(x: T, y: T): T { +>fn : (x: T, y: T) => T +>T : T +>x : T +>T : T +>y : T +>T : T +>T : T + + return x; +>x : T + } +} + + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.symbols new file mode 100644 index 00000000000..1ad7fa9223d --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.symbols @@ -0,0 +1,36 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts === +class clodule { +>clodule : Symbol(clodule, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 5, 1)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 0, 14)) + + id: string; +>id : Symbol(clodule.id, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 0, 18)) + + value: T; +>value : Symbol(clodule.value, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 1, 15)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 0, 14)) + + static fn(id: string) { } +>fn : Symbol(clodule.fn, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 2, 13)) +>id : Symbol(id, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 4, 14)) +} + +module clodule { +>clodule : Symbol(clodule, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 5, 1)) + + // error: duplicate identifier expected + export function fn(x: T, y: T): T { +>fn : Symbol(clodule.fn, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 7, 16)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 9, 26)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 9, 31)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 9, 23)) + + return x; +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts, 9, 26)) + } +} + + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.types b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.types new file mode 100644 index 00000000000..6af2e089dc3 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.ts === +class clodule { +>clodule : clodule +>T : T + + id: string; +>id : string + + value: T; +>value : T +>T : T + + static fn(id: string) { } +>fn : (id: string) => void +>id : string +} + +module clodule { +>clodule : typeof clodule + + // error: duplicate identifier expected + export function fn(x: T, y: T): T { +>fn : (x: T, y: T) => T +>T : T +>x : T +>T : T +>y : T +>T : T +>T : T + + return x; +>x : T + } +} + + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.symbols new file mode 100644 index 00000000000..13cdbdf66ae --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.symbols @@ -0,0 +1,37 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts === +class clodule { +>clodule : Symbol(clodule, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 5, 1)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 0, 14)) + + id: string; +>id : Symbol(clodule.id, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 0, 18)) + + value: T; +>value : Symbol(clodule.value, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 1, 15)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 0, 14)) + + private static sfn(id: string) { return 42; } +>sfn : Symbol(clodule.sfn, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 2, 13)) +>id : Symbol(id, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 4, 23)) +} + +module clodule { +>clodule : Symbol(clodule, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 5, 1)) + + // error: duplicate identifier expected + export function fn(x: T, y: T): number { +>fn : Symbol(fn, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 7, 16)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 9, 23)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 9, 26)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 9, 23)) +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 9, 31)) +>T : Symbol(T, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 9, 23)) + + return clodule.sfn('a'); +>clodule.sfn : Symbol(clodule.sfn, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 2, 13)) +>clodule : Symbol(clodule, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 0, 0), Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 5, 1)) +>sfn : Symbol(clodule.sfn, Decl(ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts, 2, 13)) + } +} + + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types new file mode 100644 index 00000000000..af77997ec6a --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types @@ -0,0 +1,40 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.ts === +class clodule { +>clodule : clodule +>T : T + + id: string; +>id : string + + value: T; +>value : T +>T : T + + private static sfn(id: string) { return 42; } +>sfn : (id: string) => number +>id : string +>42 : 42 +} + +module clodule { +>clodule : typeof clodule + + // error: duplicate identifier expected + export function fn(x: T, y: T): number { +>fn : (x: T, y: T) => number +>T : T +>x : T +>T : T +>y : T +>T : T + + return clodule.sfn('a'); +>clodule.sfn('a') : number +>clodule.sfn : (id: string) => number +>clodule : typeof clodule +>sfn : (id: string) => number +>'a' : "a" + } +} + + diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.symbols new file mode 100644 index 00000000000..c8ba6f0277c --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.symbols @@ -0,0 +1,47 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts === +class Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 4, 1)) + + constructor(public x: number, public y: number) { } +>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 1, 16)) +>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 1, 33)) + + static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246 +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 1, 55)) +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 4, 1)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 3, 37)) +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 3, 43)) +} + +module Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 4, 1)) + + export function Origin() { return null; } //expected duplicate identifier error +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 6, 14)) +} + + +module A { +>A : Symbol(A, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 8, 1)) + + export class Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 16, 5)) + + constructor(public x: number, public y: number) { } +>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 13, 20)) +>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 13, 37)) + + static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246 +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 13, 59)) +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 16, 5)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 15, 41)) +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 15, 47)) + } + + export module Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 16, 5)) + + export function Origin() { return ""; }//expected duplicate identifier error +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts, 18, 25)) + } +} diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types new file mode 100644 index 00000000000..f3bdde0e6a4 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types @@ -0,0 +1,55 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.ts === +class Point { +>Point : Point + + constructor(public x: number, public y: number) { } +>x : number +>y : number + + static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246 +>Origin : () => Point +>Point : Point +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 +} + +module Point { +>Point : typeof Point + + export function Origin() { return null; } //expected duplicate identifier error +>Origin : () => any +>null : null +} + + +module A { +>A : typeof A + + export class Point { +>Point : Point + + constructor(public x: number, public y: number) { } +>x : number +>y : number + + static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246 +>Origin : () => Point +>Point : Point +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } + + export module Point { +>Point : typeof Point + + export function Origin() { return ""; }//expected duplicate identifier error +>Origin : () => string +>"" : "" + } +} diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.symbols b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.symbols new file mode 100644 index 00000000000..362c149e523 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.symbols @@ -0,0 +1,47 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts === +class Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 4, 1)) + + constructor(public x: number, public y: number) { } +>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 1, 16)) +>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 1, 33)) + + static Origin: Point = { x: 0, y: 0 }; +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 1, 55)) +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 4, 1)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 3, 28)) +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 3, 34)) +} + +module Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 4, 1)) + + export var Origin = ""; //expected duplicate identifier error +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 7, 14)) +} + + +module A { +>A : Symbol(A, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 8, 1)) + + export class Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 16, 5)) + + constructor(public x: number, public y: number) { } +>x : Symbol(Point.x, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 13, 20)) +>y : Symbol(Point.y, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 13, 37)) + + static Origin: Point = { x: 0, y: 0 }; +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 13, 59)) +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 16, 5)) +>x : Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 15, 32)) +>y : Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 15, 38)) + } + + export module Point { +>Point : Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 16, 5)) + + export var Origin = ""; //expected duplicate identifier error +>Origin : Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts, 19, 18)) + } +} diff --git a/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.types b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.types new file mode 100644 index 00000000000..1c2423316dc --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.types @@ -0,0 +1,55 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.ts === +class Point { +>Point : Point + + constructor(public x: number, public y: number) { } +>x : number +>y : number + + static Origin: Point = { x: 0, y: 0 }; +>Origin : Point +>Point : Point +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 +} + +module Point { +>Point : typeof Point + + export var Origin = ""; //expected duplicate identifier error +>Origin : string +>"" : "" +} + + +module A { +>A : typeof A + + export class Point { +>Point : Point + + constructor(public x: number, public y: number) { } +>x : number +>y : number + + static Origin: Point = { x: 0, y: 0 }; +>Origin : Point +>Point : Point +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } + + export module Point { +>Point : typeof Point + + export var Origin = ""; //expected duplicate identifier error +>Origin : string +>"" : "" + } +} diff --git a/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.symbols b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.symbols new file mode 100644 index 00000000000..6fd9822c2a9 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.symbols @@ -0,0 +1,98 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/class.ts === +module X.Y { +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) + + export class Point { +>Point : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + + constructor(x: number, y: number) { +>x : Symbol(x, Decl(class.ts, 2, 20)) +>y : Symbol(y, Decl(class.ts, 2, 30)) + + this.x = x; +>this.x : Symbol(Point.x, Decl(class.ts, 5, 9)) +>this : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>x : Symbol(Point.x, Decl(class.ts, 5, 9)) +>x : Symbol(x, Decl(class.ts, 2, 20)) + + this.y = y; +>this.y : Symbol(Point.y, Decl(class.ts, 6, 18)) +>this : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>y : Symbol(Point.y, Decl(class.ts, 6, 18)) +>y : Symbol(y, Decl(class.ts, 2, 30)) + } + x: number; +>x : Symbol(Point.x, Decl(class.ts, 5, 9)) + + y: number; +>y : Symbol(Point.y, Decl(class.ts, 6, 18)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module X.Y { +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) + + export module Point { +>Point : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + + export var Origin = new Point(0, 0); +>Origin : Symbol(Origin, Decl(module.ts, 2, 18)) +>Point : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts === +//var cl: { x: number; y: number; } +var cl = new X.Y.Point(1,1); +>cl : Symbol(cl, Decl(test.ts, 1, 3), Decl(test.ts, 2, 3)) +>X.Y.Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>X.Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + +var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ? +>cl : Symbol(cl, Decl(test.ts, 1, 3), Decl(test.ts, 2, 3)) +>X.Y.Point.Origin : Symbol(X.Y.Point.Origin, Decl(module.ts, 2, 18)) +>X.Y.Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>X.Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>Origin : Symbol(X.Y.Point.Origin, Decl(module.ts, 2, 18)) + + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +class A { +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + + id: string; +>id : Symbol(A.id, Decl(simple.ts, 0, 9)) +} + +module A { +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + + export var Instance = new A(); +>Instance : Symbol(Instance, Decl(simple.ts, 5, 14)) +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) +} + +// ensure merging works as expected +var a = A.Instance; +>a : Symbol(a, Decl(simple.ts, 9, 3), Decl(simple.ts, 10, 3), Decl(simple.ts, 11, 3)) +>A.Instance : Symbol(A.Instance, Decl(simple.ts, 5, 14)) +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) +>Instance : Symbol(A.Instance, Decl(simple.ts, 5, 14)) + +var a = new A(); +>a : Symbol(a, Decl(simple.ts, 9, 3), Decl(simple.ts, 10, 3), Decl(simple.ts, 11, 3)) +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + +var a: { id: string }; +>a : Symbol(a, Decl(simple.ts, 9, 3), Decl(simple.ts, 10, 3), Decl(simple.ts, 11, 3)) +>id : Symbol(id, Decl(simple.ts, 11, 8)) + diff --git a/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.types b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.types new file mode 100644 index 00000000000..f3e05acf116 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.types @@ -0,0 +1,108 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/class.ts === +module X.Y { +>X : typeof X +>Y : typeof Y + + export class Point { +>Point : Point + + constructor(x: number, y: number) { +>x : number +>y : number + + this.x = x; +>this.x = x : number +>this.x : number +>this : this +>x : number +>x : number + + this.y = y; +>this.y = y : number +>this.y : number +>this : this +>y : number +>y : number + } + x: number; +>x : number + + y: number; +>y : number + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module X.Y { +>X : typeof X +>Y : typeof Y + + export module Point { +>Point : typeof Point + + export var Origin = new Point(0, 0); +>Origin : Point +>new Point(0, 0) : Point +>Point : typeof Point +>0 : 0 +>0 : 0 + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts === +//var cl: { x: number; y: number; } +var cl = new X.Y.Point(1,1); +>cl : X.Y.Point +>new X.Y.Point(1,1) : X.Y.Point +>X.Y.Point : typeof X.Y.Point +>X.Y : typeof X.Y +>X : typeof X +>Y : typeof X.Y +>Point : typeof X.Y.Point +>1 : 1 +>1 : 1 + +var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ? +>cl : X.Y.Point +>X.Y.Point.Origin : X.Y.Point +>X.Y.Point : typeof X.Y.Point +>X.Y : typeof X.Y +>X : typeof X +>Y : typeof X.Y +>Point : typeof X.Y.Point +>Origin : X.Y.Point + + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +class A { +>A : A + + id: string; +>id : string +} + +module A { +>A : typeof A + + export var Instance = new A(); +>Instance : A +>new A() : A +>A : typeof A +} + +// ensure merging works as expected +var a = A.Instance; +>a : A +>A.Instance : A +>A : typeof A +>Instance : A + +var a = new A(); +>a : A +>new A() : A +>A : typeof A + +var a: { id: string }; +>a : A +>id : string + diff --git a/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.symbols b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.symbols new file mode 100644 index 00000000000..6fd9822c2a9 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.symbols @@ -0,0 +1,98 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/class.ts === +module X.Y { +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) + + export class Point { +>Point : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + + constructor(x: number, y: number) { +>x : Symbol(x, Decl(class.ts, 2, 20)) +>y : Symbol(y, Decl(class.ts, 2, 30)) + + this.x = x; +>this.x : Symbol(Point.x, Decl(class.ts, 5, 9)) +>this : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>x : Symbol(Point.x, Decl(class.ts, 5, 9)) +>x : Symbol(x, Decl(class.ts, 2, 20)) + + this.y = y; +>this.y : Symbol(Point.y, Decl(class.ts, 6, 18)) +>this : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>y : Symbol(Point.y, Decl(class.ts, 6, 18)) +>y : Symbol(y, Decl(class.ts, 2, 30)) + } + x: number; +>x : Symbol(Point.x, Decl(class.ts, 5, 9)) + + y: number; +>y : Symbol(Point.y, Decl(class.ts, 6, 18)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module X.Y { +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) + + export module Point { +>Point : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + + export var Origin = new Point(0, 0); +>Origin : Symbol(Origin, Decl(module.ts, 2, 18)) +>Point : Symbol(Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts === +//var cl: { x: number; y: number; } +var cl = new X.Y.Point(1,1); +>cl : Symbol(cl, Decl(test.ts, 1, 3), Decl(test.ts, 2, 3)) +>X.Y.Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>X.Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) + +var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ? +>cl : Symbol(cl, Decl(test.ts, 1, 3), Decl(test.ts, 2, 3)) +>X.Y.Point.Origin : Symbol(X.Y.Point.Origin, Decl(module.ts, 2, 18)) +>X.Y.Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>X.Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>X : Symbol(X, Decl(class.ts, 0, 0), Decl(module.ts, 0, 0)) +>Y : Symbol(X.Y, Decl(class.ts, 0, 9), Decl(module.ts, 0, 9)) +>Point : Symbol(X.Y.Point, Decl(class.ts, 0, 12), Decl(module.ts, 0, 12)) +>Origin : Symbol(X.Y.Point.Origin, Decl(module.ts, 2, 18)) + + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +class A { +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + + id: string; +>id : Symbol(A.id, Decl(simple.ts, 0, 9)) +} + +module A { +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + + export var Instance = new A(); +>Instance : Symbol(Instance, Decl(simple.ts, 5, 14)) +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) +} + +// ensure merging works as expected +var a = A.Instance; +>a : Symbol(a, Decl(simple.ts, 9, 3), Decl(simple.ts, 10, 3), Decl(simple.ts, 11, 3)) +>A.Instance : Symbol(A.Instance, Decl(simple.ts, 5, 14)) +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) +>Instance : Symbol(A.Instance, Decl(simple.ts, 5, 14)) + +var a = new A(); +>a : Symbol(a, Decl(simple.ts, 9, 3), Decl(simple.ts, 10, 3), Decl(simple.ts, 11, 3)) +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + +var a: { id: string }; +>a : Symbol(a, Decl(simple.ts, 9, 3), Decl(simple.ts, 10, 3), Decl(simple.ts, 11, 3)) +>id : Symbol(id, Decl(simple.ts, 11, 8)) + diff --git a/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.types b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.types new file mode 100644 index 00000000000..f3e05acf116 --- /dev/null +++ b/tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.types @@ -0,0 +1,108 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/class.ts === +module X.Y { +>X : typeof X +>Y : typeof Y + + export class Point { +>Point : Point + + constructor(x: number, y: number) { +>x : number +>y : number + + this.x = x; +>this.x = x : number +>this.x : number +>this : this +>x : number +>x : number + + this.y = y; +>this.y = y : number +>this.y : number +>this : this +>y : number +>y : number + } + x: number; +>x : number + + y: number; +>y : number + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module X.Y { +>X : typeof X +>Y : typeof Y + + export module Point { +>Point : typeof Point + + export var Origin = new Point(0, 0); +>Origin : Point +>new Point(0, 0) : Point +>Point : typeof Point +>0 : 0 +>0 : 0 + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts === +//var cl: { x: number; y: number; } +var cl = new X.Y.Point(1,1); +>cl : X.Y.Point +>new X.Y.Point(1,1) : X.Y.Point +>X.Y.Point : typeof X.Y.Point +>X.Y : typeof X.Y +>X : typeof X +>Y : typeof X.Y +>Point : typeof X.Y.Point +>1 : 1 +>1 : 1 + +var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ? +>cl : X.Y.Point +>X.Y.Point.Origin : X.Y.Point +>X.Y.Point : typeof X.Y.Point +>X.Y : typeof X.Y +>X : typeof X +>Y : typeof X.Y +>Point : typeof X.Y.Point +>Origin : X.Y.Point + + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +class A { +>A : A + + id: string; +>id : string +} + +module A { +>A : typeof A + + export var Instance = new A(); +>Instance : A +>new A() : A +>A : typeof A +} + +// ensure merging works as expected +var a = A.Instance; +>a : A +>A.Instance : A +>A : typeof A +>Instance : A + +var a = new A(); +>a : A +>new A() : A +>A : typeof A + +var a: { id: string }; +>a : A +>id : string + diff --git a/tests/baselines/reference/ClassDeclaration10.symbols b/tests/baselines/reference/ClassDeclaration10.symbols new file mode 100644 index 00000000000..3b967f70cbe --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration10.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ClassDeclaration10.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration10.ts, 0, 0)) + + constructor(); + foo(); +>foo : Symbol(C.foo, Decl(ClassDeclaration10.ts, 1, 17)) +} diff --git a/tests/baselines/reference/ClassDeclaration10.types b/tests/baselines/reference/ClassDeclaration10.types new file mode 100644 index 00000000000..ec5fac03741 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration10.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ClassDeclaration10.ts === +class C { +>C : C + + constructor(); + foo(); +>foo : () => any +} diff --git a/tests/baselines/reference/ClassDeclaration11.symbols b/tests/baselines/reference/ClassDeclaration11.symbols new file mode 100644 index 00000000000..a231eaf48d3 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration11.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ClassDeclaration11.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration11.ts, 0, 0)) + + constructor(); + foo() { } +>foo : Symbol(C.foo, Decl(ClassDeclaration11.ts, 1, 17)) +} diff --git a/tests/baselines/reference/ClassDeclaration11.types b/tests/baselines/reference/ClassDeclaration11.types new file mode 100644 index 00000000000..d7b3f4f6406 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration11.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ClassDeclaration11.ts === +class C { +>C : C + + constructor(); + foo() { } +>foo : () => void +} diff --git a/tests/baselines/reference/ClassDeclaration13.symbols b/tests/baselines/reference/ClassDeclaration13.symbols new file mode 100644 index 00000000000..fe6e0706a45 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration13.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/ClassDeclaration13.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration13.ts, 0, 0)) + + foo(); +>foo : Symbol(C.foo, Decl(ClassDeclaration13.ts, 0, 9)) + + bar() { } +>bar : Symbol(C.bar, Decl(ClassDeclaration13.ts, 1, 9)) +} diff --git a/tests/baselines/reference/ClassDeclaration13.types b/tests/baselines/reference/ClassDeclaration13.types new file mode 100644 index 00000000000..353dfd02988 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration13.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/ClassDeclaration13.ts === +class C { +>C : C + + foo(); +>foo : () => any + + bar() { } +>bar : () => void +} diff --git a/tests/baselines/reference/ClassDeclaration14.symbols b/tests/baselines/reference/ClassDeclaration14.symbols new file mode 100644 index 00000000000..341f6c984aa --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration14.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/ClassDeclaration14.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration14.ts, 0, 0)) + + foo(); +>foo : Symbol(C.foo, Decl(ClassDeclaration14.ts, 0, 9)) + + constructor(); +} diff --git a/tests/baselines/reference/ClassDeclaration14.types b/tests/baselines/reference/ClassDeclaration14.types new file mode 100644 index 00000000000..7f7038d5710 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration14.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/ClassDeclaration14.ts === +class C { +>C : C + + foo(); +>foo : () => any + + constructor(); +} diff --git a/tests/baselines/reference/ClassDeclaration15.symbols b/tests/baselines/reference/ClassDeclaration15.symbols new file mode 100644 index 00000000000..da6fe683974 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration15.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/ClassDeclaration15.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration15.ts, 0, 0)) + + foo(); +>foo : Symbol(C.foo, Decl(ClassDeclaration15.ts, 0, 9)) + + constructor() { } +} diff --git a/tests/baselines/reference/ClassDeclaration15.types b/tests/baselines/reference/ClassDeclaration15.types new file mode 100644 index 00000000000..9b861b5230c --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration15.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/ClassDeclaration15.ts === +class C { +>C : C + + foo(); +>foo : () => any + + constructor() { } +} diff --git a/tests/baselines/reference/ClassDeclaration21.symbols b/tests/baselines/reference/ClassDeclaration21.symbols new file mode 100644 index 00000000000..f9bd42a3a4f --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration21.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ClassDeclaration21.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration21.ts, 0, 0)) + + 0(); + 1() { } +} diff --git a/tests/baselines/reference/ClassDeclaration21.types b/tests/baselines/reference/ClassDeclaration21.types new file mode 100644 index 00000000000..fa41bb54676 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration21.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ClassDeclaration21.ts === +class C { +>C : C + + 0(); + 1() { } +} diff --git a/tests/baselines/reference/ClassDeclaration22.symbols b/tests/baselines/reference/ClassDeclaration22.symbols new file mode 100644 index 00000000000..059ff9e825c --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration22.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ClassDeclaration22.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration22.ts, 0, 0)) + + "foo"(); + "bar"() { } +} diff --git a/tests/baselines/reference/ClassDeclaration22.types b/tests/baselines/reference/ClassDeclaration22.types new file mode 100644 index 00000000000..359ac950462 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration22.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ClassDeclaration22.ts === +class C { +>C : C + + "foo"(); + "bar"() { } +} diff --git a/tests/baselines/reference/ClassDeclaration24.symbols b/tests/baselines/reference/ClassDeclaration24.symbols new file mode 100644 index 00000000000..e3e28d99582 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration24.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/ClassDeclaration24.ts === +class any { +>any : Symbol(any, Decl(ClassDeclaration24.ts, 0, 0)) +} diff --git a/tests/baselines/reference/ClassDeclaration24.types b/tests/baselines/reference/ClassDeclaration24.types new file mode 100644 index 00000000000..9d39e77c08b --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration24.types @@ -0,0 +1,4 @@ +=== tests/cases/compiler/ClassDeclaration24.ts === +class any { +>any : any +} diff --git a/tests/baselines/reference/ClassDeclaration25.symbols b/tests/baselines/reference/ClassDeclaration25.symbols new file mode 100644 index 00000000000..3d792b0b8f4 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration25.symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/ClassDeclaration25.ts === +interface IList { +>IList : Symbol(IList, Decl(ClassDeclaration25.ts, 0, 0)) +>T : Symbol(T, Decl(ClassDeclaration25.ts, 0, 16)) + + data(): T; +>data : Symbol(IList.data, Decl(ClassDeclaration25.ts, 0, 20)) +>T : Symbol(T, Decl(ClassDeclaration25.ts, 0, 16)) + + next(): string; +>next : Symbol(IList.next, Decl(ClassDeclaration25.ts, 1, 14)) +} +class List implements IList { +>List : Symbol(List, Decl(ClassDeclaration25.ts, 3, 1)) +>U : Symbol(U, Decl(ClassDeclaration25.ts, 4, 11)) +>IList : Symbol(IList, Decl(ClassDeclaration25.ts, 0, 0)) +>U : Symbol(U, Decl(ClassDeclaration25.ts, 4, 11)) + + data(): U; +>data : Symbol(List.data, Decl(ClassDeclaration25.ts, 4, 35)) +>U : Symbol(U, Decl(ClassDeclaration25.ts, 4, 11)) + + next(): string; +>next : Symbol(List.next, Decl(ClassDeclaration25.ts, 5, 14)) +} + diff --git a/tests/baselines/reference/ClassDeclaration25.types b/tests/baselines/reference/ClassDeclaration25.types new file mode 100644 index 00000000000..cdfc8f9ae1e --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration25.types @@ -0,0 +1,26 @@ +=== tests/cases/compiler/ClassDeclaration25.ts === +interface IList { +>IList : IList +>T : T + + data(): T; +>data : () => T +>T : T + + next(): string; +>next : () => string +} +class List implements IList { +>List : List +>U : U +>IList : IList +>U : U + + data(): U; +>data : () => U +>U : U + + next(): string; +>next : () => string +} + diff --git a/tests/baselines/reference/ClassDeclaration26.symbols b/tests/baselines/reference/ClassDeclaration26.symbols new file mode 100644 index 00000000000..cc4757b97de --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration26.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/ClassDeclaration26.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration26.ts, 0, 0)) + + public const var export foo = 10; +>var : Symbol(C.var, Decl(ClassDeclaration26.ts, 0, 9)) +>foo : Symbol(C.foo, Decl(ClassDeclaration26.ts, 1, 20)) + + var constructor() { } +>constructor : Symbol(constructor, Decl(ClassDeclaration26.ts, 3, 7)) +} diff --git a/tests/baselines/reference/ClassDeclaration26.types b/tests/baselines/reference/ClassDeclaration26.types new file mode 100644 index 00000000000..acdc0d56ab1 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration26.types @@ -0,0 +1,13 @@ +=== tests/cases/compiler/ClassDeclaration26.ts === +class C { +>C : C + + public const var export foo = 10; +>var : any +>foo : number +>10 : 10 + + var constructor() { } +>constructor : () => void +>() { } : () => void +} diff --git a/tests/baselines/reference/ClassDeclaration8.symbols b/tests/baselines/reference/ClassDeclaration8.symbols new file mode 100644 index 00000000000..bec50a10bbf --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration8.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/ClassDeclaration8.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration8.ts, 0, 0)) + + constructor(); +} diff --git a/tests/baselines/reference/ClassDeclaration8.types b/tests/baselines/reference/ClassDeclaration8.types new file mode 100644 index 00000000000..5f89e84680f --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration8.types @@ -0,0 +1,6 @@ +=== tests/cases/compiler/ClassDeclaration8.ts === +class C { +>C : C + + constructor(); +} diff --git a/tests/baselines/reference/ClassDeclaration9.symbols b/tests/baselines/reference/ClassDeclaration9.symbols new file mode 100644 index 00000000000..7a853b8b61b --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration9.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ClassDeclaration9.ts === +class C { +>C : Symbol(C, Decl(ClassDeclaration9.ts, 0, 0)) + + foo(); +>foo : Symbol(C.foo, Decl(ClassDeclaration9.ts, 0, 9)) +} diff --git a/tests/baselines/reference/ClassDeclaration9.types b/tests/baselines/reference/ClassDeclaration9.types new file mode 100644 index 00000000000..f9193d6d567 --- /dev/null +++ b/tests/baselines/reference/ClassDeclaration9.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ClassDeclaration9.ts === +class C { +>C : C + + foo(); +>foo : () => any +} diff --git a/tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.symbols b/tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.symbols new file mode 100644 index 00000000000..5c9bb23a923 --- /dev/null +++ b/tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ClassDeclarationWithInvalidConstOnPropertyDeclaration.ts === +class AtomicNumbers { +>AtomicNumbers : Symbol(AtomicNumbers, Decl(ClassDeclarationWithInvalidConstOnPropertyDeclaration.ts, 0, 0)) + + static const H = 1; +>H : Symbol(AtomicNumbers.H, Decl(ClassDeclarationWithInvalidConstOnPropertyDeclaration.ts, 0, 21)) +} diff --git a/tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.types b/tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.types new file mode 100644 index 00000000000..81ec49120fd --- /dev/null +++ b/tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ClassDeclarationWithInvalidConstOnPropertyDeclaration.ts === +class AtomicNumbers { +>AtomicNumbers : AtomicNumbers + + static const H = 1; +>H : number +>1 : 1 +} diff --git a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols new file mode 100644 index 00000000000..f57bd8d6cc4 --- /dev/null +++ b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.symbols @@ -0,0 +1,12 @@ +=== tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts === +type T = { x : number } +>T : Symbol(T, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 0)) +>x : Symbol(x, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 10)) + +export interface I { +>I : Symbol(I, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 23)) + + f: T; +>f : Symbol(I.f, Decl(DeclarationErrorsNoEmitOnError.ts, 1, 20)) +>T : Symbol(T, Decl(DeclarationErrorsNoEmitOnError.ts, 0, 0)) +} diff --git a/tests/baselines/reference/DeclarationErrorsNoEmitOnError.types b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.types new file mode 100644 index 00000000000..08a65d9c146 --- /dev/null +++ b/tests/baselines/reference/DeclarationErrorsNoEmitOnError.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts === +type T = { x : number } +>T : { x: number; } +>x : number + +export interface I { +>I : I + + f: T; +>f : { x: number; } +>T : { x: number; } +} diff --git a/tests/baselines/reference/ES3For-ofTypeCheck1.symbols b/tests/baselines/reference/ES3For-ofTypeCheck1.symbols new file mode 100644 index 00000000000..c7d17a31763 --- /dev/null +++ b/tests/baselines/reference/ES3For-ofTypeCheck1.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck1.ts === +for (var v of "") { } +>v : Symbol(v, Decl(ES3For-ofTypeCheck1.ts, 0, 8)) + diff --git a/tests/baselines/reference/ES3For-ofTypeCheck1.types b/tests/baselines/reference/ES3For-ofTypeCheck1.types new file mode 100644 index 00000000000..3b5af3905cc --- /dev/null +++ b/tests/baselines/reference/ES3For-ofTypeCheck1.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck1.ts === +for (var v of "") { } +>v : string +>"" : "" + diff --git a/tests/baselines/reference/ES3For-ofTypeCheck4.symbols b/tests/baselines/reference/ES3For-ofTypeCheck4.symbols new file mode 100644 index 00000000000..31c862025b9 --- /dev/null +++ b/tests/baselines/reference/ES3For-ofTypeCheck4.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck4.ts === +var union: string | string[]; +>union : Symbol(union, Decl(ES3For-ofTypeCheck4.ts, 0, 3)) + +for (const v of union) { } +>v : Symbol(v, Decl(ES3For-ofTypeCheck4.ts, 1, 10)) +>union : Symbol(union, Decl(ES3For-ofTypeCheck4.ts, 0, 3)) + diff --git a/tests/baselines/reference/ES3For-ofTypeCheck4.types b/tests/baselines/reference/ES3For-ofTypeCheck4.types new file mode 100644 index 00000000000..bec14ff259f --- /dev/null +++ b/tests/baselines/reference/ES3For-ofTypeCheck4.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck4.ts === +var union: string | string[]; +>union : string | string[] + +for (const v of union) { } +>v : string +>union : string | string[] + diff --git a/tests/baselines/reference/ES5For-of1.symbols b/tests/baselines/reference/ES5For-of1.symbols new file mode 100644 index 00000000000..a80c69cd2cf --- /dev/null +++ b/tests/baselines/reference/ES5For-of1.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of1.ts === +for (var v of ['a', 'b', 'c']) { +>v : Symbol(v, Decl(ES5For-of1.ts, 0, 8)) + + console.log(v); +>v : Symbol(v, Decl(ES5For-of1.ts, 0, 8)) +} diff --git a/tests/baselines/reference/ES5For-of1.types b/tests/baselines/reference/ES5For-of1.types new file mode 100644 index 00000000000..4f9117740fb --- /dev/null +++ b/tests/baselines/reference/ES5For-of1.types @@ -0,0 +1,15 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of1.ts === +for (var v of ['a', 'b', 'c']) { +>v : string +>['a', 'b', 'c'] : string[] +>'a' : "a" +>'b' : "b" +>'c' : "c" + + console.log(v); +>console.log(v) : any +>console.log : any +>console : any +>log : any +>v : string +} diff --git a/tests/baselines/reference/ES5For-of12.symbols b/tests/baselines/reference/ES5For-of12.symbols new file mode 100644 index 00000000000..465a644f7bf --- /dev/null +++ b/tests/baselines/reference/ES5For-of12.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of12.ts === +for ([""] of [[""]]) { } +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/ES5For-of12.types b/tests/baselines/reference/ES5For-of12.types new file mode 100644 index 00000000000..42ea34cd617 --- /dev/null +++ b/tests/baselines/reference/ES5For-of12.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of12.ts === +for ([""] of [[""]]) { } +>[""] : [string] +>"" : "" +>[[""]] : string[][] +>[""] : string[] +>"" : "" + diff --git a/tests/baselines/reference/ES5For-of17.symbols b/tests/baselines/reference/ES5For-of17.symbols new file mode 100644 index 00000000000..277ffda267e --- /dev/null +++ b/tests/baselines/reference/ES5For-of17.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of17.ts === +for (let v of []) { +>v : Symbol(v, Decl(ES5For-of17.ts, 0, 8)) + + v; +>v : Symbol(v, Decl(ES5For-of17.ts, 0, 8)) + + for (let v of [v]) { +>v : Symbol(v, Decl(ES5For-of17.ts, 2, 12)) +>v : Symbol(v, Decl(ES5For-of17.ts, 2, 12)) + + var x = v; +>x : Symbol(x, Decl(ES5For-of17.ts, 3, 11)) +>v : Symbol(v, Decl(ES5For-of17.ts, 2, 12)) + + v++; +>v : Symbol(v, Decl(ES5For-of17.ts, 2, 12)) + } +} diff --git a/tests/baselines/reference/ES5For-of17.types b/tests/baselines/reference/ES5For-of17.types new file mode 100644 index 00000000000..4dafdc0599d --- /dev/null +++ b/tests/baselines/reference/ES5For-of17.types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of17.ts === +for (let v of []) { +>v : any +>[] : undefined[] + + v; +>v : any + + for (let v of [v]) { +>v : any +>[v] : any[] +>v : any + + var x = v; +>x : any +>v : any + + v++; +>v++ : number +>v : any + } +} diff --git a/tests/baselines/reference/ES5For-of20.symbols b/tests/baselines/reference/ES5For-of20.symbols new file mode 100644 index 00000000000..01104e621a9 --- /dev/null +++ b/tests/baselines/reference/ES5For-of20.symbols @@ -0,0 +1,15 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of20.ts === +for (let v of []) { +>v : Symbol(v, Decl(ES5For-of20.ts, 0, 8)) + + let v; +>v : Symbol(v, Decl(ES5For-of20.ts, 1, 7)) + + for (let v of [v]) { +>v : Symbol(v, Decl(ES5For-of20.ts, 2, 12)) +>v : Symbol(v, Decl(ES5For-of20.ts, 2, 12)) + + const v; +>v : Symbol(v, Decl(ES5For-of20.ts, 3, 13)) + } +} diff --git a/tests/baselines/reference/ES5For-of20.types b/tests/baselines/reference/ES5For-of20.types new file mode 100644 index 00000000000..3b07913c3b0 --- /dev/null +++ b/tests/baselines/reference/ES5For-of20.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of20.ts === +for (let v of []) { +>v : any +>[] : undefined[] + + let v; +>v : any + + for (let v of [v]) { +>v : any +>[v] : any[] +>v : any + + const v; +>v : any + } +} diff --git a/tests/baselines/reference/ES5For-of22.symbols b/tests/baselines/reference/ES5For-of22.symbols new file mode 100644 index 00000000000..6511d8c9a8b --- /dev/null +++ b/tests/baselines/reference/ES5For-of22.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of22.ts === +for (var x of [1, 2, 3]) { +>x : Symbol(x, Decl(ES5For-of22.ts, 0, 8)) + + let _a = 0; +>_a : Symbol(_a, Decl(ES5For-of22.ts, 1, 7)) + + console.log(x); +>x : Symbol(x, Decl(ES5For-of22.ts, 0, 8)) +} diff --git a/tests/baselines/reference/ES5For-of22.types b/tests/baselines/reference/ES5For-of22.types new file mode 100644 index 00000000000..ec99c310bf7 --- /dev/null +++ b/tests/baselines/reference/ES5For-of22.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of22.ts === +for (var x of [1, 2, 3]) { +>x : number +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + + let _a = 0; +>_a : number +>0 : 0 + + console.log(x); +>console.log(x) : any +>console.log : any +>console : any +>log : any +>x : number +} diff --git a/tests/baselines/reference/ES5For-of23.symbols b/tests/baselines/reference/ES5For-of23.symbols new file mode 100644 index 00000000000..7b030d4e1e3 --- /dev/null +++ b/tests/baselines/reference/ES5For-of23.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of23.ts === +for (var x of [1, 2, 3]) { +>x : Symbol(x, Decl(ES5For-of23.ts, 0, 8)) + + var _a = 0; +>_a : Symbol(_a, Decl(ES5For-of23.ts, 1, 7)) + + console.log(x); +>x : Symbol(x, Decl(ES5For-of23.ts, 0, 8)) +} diff --git a/tests/baselines/reference/ES5For-of23.types b/tests/baselines/reference/ES5For-of23.types new file mode 100644 index 00000000000..c519e1c6ee2 --- /dev/null +++ b/tests/baselines/reference/ES5For-of23.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of23.ts === +for (var x of [1, 2, 3]) { +>x : number +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + + var _a = 0; +>_a : number +>0 : 0 + + console.log(x); +>console.log(x) : any +>console.log : any +>console : any +>log : any +>x : number +} diff --git a/tests/baselines/reference/ES5For-of26.symbols b/tests/baselines/reference/ES5For-of26.symbols new file mode 100644 index 00000000000..0c54eaea824 --- /dev/null +++ b/tests/baselines/reference/ES5For-of26.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of26.ts === +for (var [a = 0, b = 1] of [2, 3]) { +>a : Symbol(a, Decl(ES5For-of26.ts, 0, 10)) +>b : Symbol(b, Decl(ES5For-of26.ts, 0, 16)) + + a; +>a : Symbol(a, Decl(ES5For-of26.ts, 0, 10)) + + b; +>b : Symbol(b, Decl(ES5For-of26.ts, 0, 16)) +} diff --git a/tests/baselines/reference/ES5For-of26.types b/tests/baselines/reference/ES5For-of26.types new file mode 100644 index 00000000000..17cac39a723 --- /dev/null +++ b/tests/baselines/reference/ES5For-of26.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of26.ts === +for (var [a = 0, b = 1] of [2, 3]) { +>a : any +>0 : 0 +>b : any +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 + + a; +>a : any + + b; +>b : any +} diff --git a/tests/baselines/reference/ES5For-of27.symbols b/tests/baselines/reference/ES5For-of27.symbols new file mode 100644 index 00000000000..31348c4ca8a --- /dev/null +++ b/tests/baselines/reference/ES5For-of27.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of27.ts === +for (var {x: a = 0, y: b = 1} of [2, 3]) { +>a : Symbol(a, Decl(ES5For-of27.ts, 0, 10)) +>b : Symbol(b, Decl(ES5For-of27.ts, 0, 19)) + + a; +>a : Symbol(a, Decl(ES5For-of27.ts, 0, 10)) + + b; +>b : Symbol(b, Decl(ES5For-of27.ts, 0, 19)) +} diff --git a/tests/baselines/reference/ES5For-of27.types b/tests/baselines/reference/ES5For-of27.types new file mode 100644 index 00000000000..3bdc3fe9118 --- /dev/null +++ b/tests/baselines/reference/ES5For-of27.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of27.ts === +for (var {x: a = 0, y: b = 1} of [2, 3]) { +>x : any +>a : any +>0 : 0 +>y : any +>b : any +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 + + a; +>a : any + + b; +>b : any +} diff --git a/tests/baselines/reference/ES5For-of28.symbols b/tests/baselines/reference/ES5For-of28.symbols new file mode 100644 index 00000000000..53e1de495ac --- /dev/null +++ b/tests/baselines/reference/ES5For-of28.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of28.ts === +for (let [a = 0, b = 1] of [2, 3]) { +>a : Symbol(a, Decl(ES5For-of28.ts, 0, 10)) +>b : Symbol(b, Decl(ES5For-of28.ts, 0, 16)) + + a; +>a : Symbol(a, Decl(ES5For-of28.ts, 0, 10)) + + b; +>b : Symbol(b, Decl(ES5For-of28.ts, 0, 16)) +} diff --git a/tests/baselines/reference/ES5For-of28.types b/tests/baselines/reference/ES5For-of28.types new file mode 100644 index 00000000000..76646ef7596 --- /dev/null +++ b/tests/baselines/reference/ES5For-of28.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of28.ts === +for (let [a = 0, b = 1] of [2, 3]) { +>a : any +>0 : 0 +>b : any +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 + + a; +>a : any + + b; +>b : any +} diff --git a/tests/baselines/reference/ES5For-of29.symbols b/tests/baselines/reference/ES5For-of29.symbols new file mode 100644 index 00000000000..efe7c386741 --- /dev/null +++ b/tests/baselines/reference/ES5For-of29.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of29.ts === +for (const {x: a = 0, y: b = 1} of [2, 3]) { +>a : Symbol(a, Decl(ES5For-of29.ts, 0, 12)) +>b : Symbol(b, Decl(ES5For-of29.ts, 0, 21)) + + a; +>a : Symbol(a, Decl(ES5For-of29.ts, 0, 12)) + + b; +>b : Symbol(b, Decl(ES5For-of29.ts, 0, 21)) +} diff --git a/tests/baselines/reference/ES5For-of29.types b/tests/baselines/reference/ES5For-of29.types new file mode 100644 index 00000000000..687dcef6bd5 --- /dev/null +++ b/tests/baselines/reference/ES5For-of29.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of29.ts === +for (const {x: a = 0, y: b = 1} of [2, 3]) { +>x : any +>a : any +>0 : 0 +>y : any +>b : any +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 + + a; +>a : any + + b; +>b : any +} diff --git a/tests/baselines/reference/ES5For-of30.symbols b/tests/baselines/reference/ES5For-of30.symbols new file mode 100644 index 00000000000..60cb2a0a1f5 --- /dev/null +++ b/tests/baselines/reference/ES5For-of30.symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts === +var a: string, b: number; +>a : Symbol(a, Decl(ES5For-of30.ts, 0, 3)) +>b : Symbol(b, Decl(ES5For-of30.ts, 0, 14)) + +var tuple: [number, string] = [2, "3"]; +>tuple : Symbol(tuple, Decl(ES5For-of30.ts, 1, 3)) + +for ([a = 1, b = ""] of tuple) { +>a : Symbol(a, Decl(ES5For-of30.ts, 0, 3)) +>b : Symbol(b, Decl(ES5For-of30.ts, 0, 14)) +>tuple : Symbol(tuple, Decl(ES5For-of30.ts, 1, 3)) + + a; +>a : Symbol(a, Decl(ES5For-of30.ts, 0, 3)) + + b; +>b : Symbol(b, Decl(ES5For-of30.ts, 0, 14)) +} diff --git a/tests/baselines/reference/ES5For-of30.types b/tests/baselines/reference/ES5For-of30.types new file mode 100644 index 00000000000..e55ead743ad --- /dev/null +++ b/tests/baselines/reference/ES5For-of30.types @@ -0,0 +1,27 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts === +var a: string, b: number; +>a : string +>b : number + +var tuple: [number, string] = [2, "3"]; +>tuple : [number, string] +>[2, "3"] : [number, string] +>2 : 2 +>"3" : "3" + +for ([a = 1, b = ""] of tuple) { +>[a = 1, b = ""] : [number, string] +>a = 1 : 1 +>a : string +>1 : 1 +>b = "" : "" +>b : number +>"" : "" +>tuple : [number, string] + + a; +>a : string + + b; +>b : number +} diff --git a/tests/baselines/reference/ES5For-of31.symbols b/tests/baselines/reference/ES5For-of31.symbols new file mode 100644 index 00000000000..73c355fdad2 --- /dev/null +++ b/tests/baselines/reference/ES5For-of31.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of31.ts === +var a: string, b: number; +>a : Symbol(a, Decl(ES5For-of31.ts, 0, 3)) +>b : Symbol(b, Decl(ES5For-of31.ts, 0, 14)) + +for ({ a: b = 1, b: a = ""} of []) { +>a : Symbol(a, Decl(ES5For-of31.ts, 2, 6)) +>b : Symbol(b, Decl(ES5For-of31.ts, 0, 14)) +>b : Symbol(b, Decl(ES5For-of31.ts, 2, 16)) +>a : Symbol(a, Decl(ES5For-of31.ts, 0, 3)) + + a; +>a : Symbol(a, Decl(ES5For-of31.ts, 0, 3)) + + b; +>b : Symbol(b, Decl(ES5For-of31.ts, 0, 14)) +} diff --git a/tests/baselines/reference/ES5For-of31.types b/tests/baselines/reference/ES5For-of31.types new file mode 100644 index 00000000000..ee12f3894a8 --- /dev/null +++ b/tests/baselines/reference/ES5For-of31.types @@ -0,0 +1,23 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of31.ts === +var a: string, b: number; +>a : string +>b : number + +for ({ a: b = 1, b: a = ""} of []) { +>{ a: b = 1, b: a = ""} : { a?: number; b?: string; } +>a : undefined +>b = 1 : 1 +>b : number +>1 : 1 +>b : undefined +>a = "" : "" +>a : string +>"" : "" +>[] : undefined[] + + a; +>a : string + + b; +>b : number +} diff --git a/tests/baselines/reference/ES5For-of33.symbols b/tests/baselines/reference/ES5For-of33.symbols new file mode 100644 index 00000000000..0d3008a5533 --- /dev/null +++ b/tests/baselines/reference/ES5For-of33.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts === +for (var v of ['a', 'b', 'c']) { +>v : Symbol(v, Decl(ES5For-of33.ts, 0, 8)) + + console.log(v); +>v : Symbol(v, Decl(ES5For-of33.ts, 0, 8)) +} diff --git a/tests/baselines/reference/ES5For-of33.types b/tests/baselines/reference/ES5For-of33.types new file mode 100644 index 00000000000..2bcd7b9fc35 --- /dev/null +++ b/tests/baselines/reference/ES5For-of33.types @@ -0,0 +1,15 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of33.ts === +for (var v of ['a', 'b', 'c']) { +>v : string +>['a', 'b', 'c'] : string[] +>'a' : "a" +>'b' : "b" +>'c' : "c" + + console.log(v); +>console.log(v) : any +>console.log : any +>console : any +>log : any +>v : string +} diff --git a/tests/baselines/reference/ES5For-of34.symbols b/tests/baselines/reference/ES5For-of34.symbols new file mode 100644 index 00000000000..134a7b985b9 --- /dev/null +++ b/tests/baselines/reference/ES5For-of34.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of34.ts === +function foo() { +>foo : Symbol(foo, Decl(ES5For-of34.ts, 0, 0)) + + return { x: 0 }; +>x : Symbol(x, Decl(ES5For-of34.ts, 1, 12)) +} +for (foo().x of ['a', 'b', 'c']) { +>foo().x : Symbol(x, Decl(ES5For-of34.ts, 1, 12)) +>foo : Symbol(foo, Decl(ES5For-of34.ts, 0, 0)) +>x : Symbol(x, Decl(ES5For-of34.ts, 1, 12)) + + var p = foo().x; +>p : Symbol(p, Decl(ES5For-of34.ts, 4, 7)) +>foo().x : Symbol(x, Decl(ES5For-of34.ts, 1, 12)) +>foo : Symbol(foo, Decl(ES5For-of34.ts, 0, 0)) +>x : Symbol(x, Decl(ES5For-of34.ts, 1, 12)) +} diff --git a/tests/baselines/reference/ES5For-of34.types b/tests/baselines/reference/ES5For-of34.types new file mode 100644 index 00000000000..c565b8c8e87 --- /dev/null +++ b/tests/baselines/reference/ES5For-of34.types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of34.ts === +function foo() { +>foo : () => { x: number; } + + return { x: 0 }; +>{ x: 0 } : { x: number; } +>x : number +>0 : 0 +} +for (foo().x of ['a', 'b', 'c']) { +>foo().x : number +>foo() : { x: number; } +>foo : () => { x: number; } +>x : number +>['a', 'b', 'c'] : string[] +>'a' : "a" +>'b' : "b" +>'c' : "c" + + var p = foo().x; +>p : number +>foo().x : number +>foo() : { x: number; } +>foo : () => { x: number; } +>x : number +} diff --git a/tests/baselines/reference/ES5For-of35.symbols b/tests/baselines/reference/ES5For-of35.symbols new file mode 100644 index 00000000000..e8dcb07ca5a --- /dev/null +++ b/tests/baselines/reference/ES5For-of35.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts === +for (const {x: a = 0, y: b = 1} of [2, 3]) { +>a : Symbol(a, Decl(ES5For-of35.ts, 0, 12)) +>b : Symbol(b, Decl(ES5For-of35.ts, 0, 21)) + + a; +>a : Symbol(a, Decl(ES5For-of35.ts, 0, 12)) + + b; +>b : Symbol(b, Decl(ES5For-of35.ts, 0, 21)) +} diff --git a/tests/baselines/reference/ES5For-of35.types b/tests/baselines/reference/ES5For-of35.types new file mode 100644 index 00000000000..dab1b49c57a --- /dev/null +++ b/tests/baselines/reference/ES5For-of35.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of35.ts === +for (const {x: a = 0, y: b = 1} of [2, 3]) { +>x : any +>a : any +>0 : 0 +>y : any +>b : any +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 + + a; +>a : any + + b; +>b : any +} diff --git a/tests/baselines/reference/ES5For-of36.symbols b/tests/baselines/reference/ES5For-of36.symbols new file mode 100644 index 00000000000..d93f5e3f34b --- /dev/null +++ b/tests/baselines/reference/ES5For-of36.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of36.ts === +for (let [a = 0, b = 1] of [2, 3]) { +>a : Symbol(a, Decl(ES5For-of36.ts, 0, 10)) +>b : Symbol(b, Decl(ES5For-of36.ts, 0, 16)) + + a; +>a : Symbol(a, Decl(ES5For-of36.ts, 0, 10)) + + b; +>b : Symbol(b, Decl(ES5For-of36.ts, 0, 16)) +} diff --git a/tests/baselines/reference/ES5For-of36.types b/tests/baselines/reference/ES5For-of36.types new file mode 100644 index 00000000000..89b88e8b335 --- /dev/null +++ b/tests/baselines/reference/ES5For-of36.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of36.ts === +for (let [a = 0, b = 1] of [2, 3]) { +>a : any +>0 : 0 +>b : any +>1 : 1 +>[2, 3] : number[] +>2 : 2 +>3 : 3 + + a; +>a : any + + b; +>b : any +} diff --git a/tests/baselines/reference/ES5For-of7.symbols b/tests/baselines/reference/ES5For-of7.symbols new file mode 100644 index 00000000000..c6cb92b6d88 --- /dev/null +++ b/tests/baselines/reference/ES5For-of7.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of7.ts === +for (var w of []) { +>w : Symbol(w, Decl(ES5For-of7.ts, 0, 8)) + + var x = w; +>x : Symbol(x, Decl(ES5For-of7.ts, 1, 7), Decl(ES5For-of7.ts, 5, 7)) +>w : Symbol(w, Decl(ES5For-of7.ts, 0, 8)) +} + +for (var v of []) { +>v : Symbol(v, Decl(ES5For-of7.ts, 4, 8)) + + var x = [w, v]; +>x : Symbol(x, Decl(ES5For-of7.ts, 1, 7), Decl(ES5For-of7.ts, 5, 7)) +>w : Symbol(w, Decl(ES5For-of7.ts, 0, 8)) +>v : Symbol(v, Decl(ES5For-of7.ts, 4, 8)) +} diff --git a/tests/baselines/reference/ES5For-of7.types b/tests/baselines/reference/ES5For-of7.types new file mode 100644 index 00000000000..6e1fdc25ea9 --- /dev/null +++ b/tests/baselines/reference/ES5For-of7.types @@ -0,0 +1,20 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of7.ts === +for (var w of []) { +>w : any +>[] : undefined[] + + var x = w; +>x : any +>w : any +} + +for (var v of []) { +>v : any +>[] : undefined[] + + var x = [w, v]; +>x : any +>[w, v] : any[] +>w : any +>v : any +} diff --git a/tests/baselines/reference/ES5For-of8.symbols b/tests/baselines/reference/ES5For-of8.symbols new file mode 100644 index 00000000000..e04c3ee7c09 --- /dev/null +++ b/tests/baselines/reference/ES5For-of8.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of8.ts === +function foo() { +>foo : Symbol(foo, Decl(ES5For-of8.ts, 0, 0)) + + return { x: 0 }; +>x : Symbol(x, Decl(ES5For-of8.ts, 1, 12)) +} +for (foo().x of ['a', 'b', 'c']) { +>foo().x : Symbol(x, Decl(ES5For-of8.ts, 1, 12)) +>foo : Symbol(foo, Decl(ES5For-of8.ts, 0, 0)) +>x : Symbol(x, Decl(ES5For-of8.ts, 1, 12)) + + var p = foo().x; +>p : Symbol(p, Decl(ES5For-of8.ts, 4, 7)) +>foo().x : Symbol(x, Decl(ES5For-of8.ts, 1, 12)) +>foo : Symbol(foo, Decl(ES5For-of8.ts, 0, 0)) +>x : Symbol(x, Decl(ES5For-of8.ts, 1, 12)) +} diff --git a/tests/baselines/reference/ES5For-of8.types b/tests/baselines/reference/ES5For-of8.types new file mode 100644 index 00000000000..eca192ab612 --- /dev/null +++ b/tests/baselines/reference/ES5For-of8.types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-of8.ts === +function foo() { +>foo : () => { x: number; } + + return { x: 0 }; +>{ x: 0 } : { x: number; } +>x : number +>0 : 0 +} +for (foo().x of ['a', 'b', 'c']) { +>foo().x : number +>foo() : { x: number; } +>foo : () => { x: number; } +>x : number +>['a', 'b', 'c'] : string[] +>'a' : "a" +>'b' : "b" +>'c' : "c" + + var p = foo().x; +>p : number +>foo().x : number +>foo() : { x: number; } +>foo : () => { x: number; } +>x : number +} diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.symbols b/tests/baselines/reference/ES5For-ofTypeCheck10.symbols new file mode 100644 index 00000000000..f3b30e9dfc1 --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck10.symbols @@ -0,0 +1,27 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts === +// In ES3/5, you cannot for...of over an arbitrary iterable. +class StringIterator { +>StringIterator : Symbol(StringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0)) + + next() { +>next : Symbol(StringIterator.next, Decl(ES5For-ofTypeCheck10.ts, 1, 22)) + + return { + done: true, +>done : Symbol(done, Decl(ES5For-ofTypeCheck10.ts, 3, 16)) + + value: "" +>value : Symbol(value, Decl(ES5For-ofTypeCheck10.ts, 4, 23)) + + }; + } + [Symbol.iterator]() { + return this; +>this : Symbol(StringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0)) + } +} + +for (var v of new StringIterator) { } +>v : Symbol(v, Decl(ES5For-ofTypeCheck10.ts, 13, 8)) +>StringIterator : Symbol(StringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0)) + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.types b/tests/baselines/reference/ES5For-ofTypeCheck10.types new file mode 100644 index 00000000000..8cc3dd26a54 --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck10.types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts === +// In ES3/5, you cannot for...of over an arbitrary iterable. +class StringIterator { +>StringIterator : StringIterator + + next() { +>next : () => { done: boolean; value: string; } + + return { +>{ done: true, value: "" } : { done: boolean; value: string; } + + done: true, +>done : boolean +>true : true + + value: "" +>value : string +>"" : "" + + }; + } + [Symbol.iterator]() { +>Symbol.iterator : any +>Symbol : any +>iterator : any + + return this; +>this : this + } +} + +for (var v of new StringIterator) { } +>v : any +>new StringIterator : StringIterator +>StringIterator : typeof StringIterator + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck11.symbols b/tests/baselines/reference/ES5For-ofTypeCheck11.symbols new file mode 100644 index 00000000000..412920f67de --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck11.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts === +var union: string | number[]; +>union : Symbol(union, Decl(ES5For-ofTypeCheck11.ts, 0, 3)) + +var v: string; +>v : Symbol(v, Decl(ES5For-ofTypeCheck11.ts, 1, 3)) + +for (v of union) { } +>v : Symbol(v, Decl(ES5For-ofTypeCheck11.ts, 1, 3)) +>union : Symbol(union, Decl(ES5For-ofTypeCheck11.ts, 0, 3)) + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck11.types b/tests/baselines/reference/ES5For-ofTypeCheck11.types new file mode 100644 index 00000000000..c18aa4bcd87 --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck11.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts === +var union: string | number[]; +>union : string | number[] + +var v: string; +>v : string + +for (v of union) { } +>v : string +>union : string | number[] + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck12.symbols b/tests/baselines/reference/ES5For-ofTypeCheck12.symbols new file mode 100644 index 00000000000..425aeb6e63f --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck12.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck12.ts === +for (const v of 0) { } +>v : Symbol(v, Decl(ES5For-ofTypeCheck12.ts, 0, 10)) + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck12.types b/tests/baselines/reference/ES5For-ofTypeCheck12.types new file mode 100644 index 00000000000..533c44edd51 --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck12.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck12.ts === +for (const v of 0) { } +>v : any +>0 : 0 + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck7.symbols b/tests/baselines/reference/ES5For-ofTypeCheck7.symbols new file mode 100644 index 00000000000..ecdce4da59e --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck7.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck7.ts === +var union: string | number; +>union : Symbol(union, Decl(ES5For-ofTypeCheck7.ts, 0, 3)) + +for (var v of union) { } +>v : Symbol(v, Decl(ES5For-ofTypeCheck7.ts, 1, 8)) +>union : Symbol(union, Decl(ES5For-ofTypeCheck7.ts, 0, 3)) + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck7.types b/tests/baselines/reference/ES5For-ofTypeCheck7.types new file mode 100644 index 00000000000..846fc0b8bfc --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck7.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck7.ts === +var union: string | number; +>union : string | number + +for (var v of union) { } +>v : string +>union : string | number + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck8.symbols b/tests/baselines/reference/ES5For-ofTypeCheck8.symbols new file mode 100644 index 00000000000..67af60ffbd1 --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck8.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck8.ts === +var union: string | string[]| number[]| symbol[]; +>union : Symbol(union, Decl(ES5For-ofTypeCheck8.ts, 0, 3)) + +var v: symbol; +>v : Symbol(v, Decl(ES5For-ofTypeCheck8.ts, 1, 3)) + +for (v of union) { } +>v : Symbol(v, Decl(ES5For-ofTypeCheck8.ts, 1, 3)) +>union : Symbol(union, Decl(ES5For-ofTypeCheck8.ts, 0, 3)) + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck8.types b/tests/baselines/reference/ES5For-ofTypeCheck8.types new file mode 100644 index 00000000000..6888680db93 --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck8.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck8.ts === +var union: string | string[]| number[]| symbol[]; +>union : string | string[] | number[] | symbol[] + +var v: symbol; +>v : symbol + +for (v of union) { } +>v : symbol +>union : string | string[] | number[] | symbol[] + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck9.symbols b/tests/baselines/reference/ES5For-ofTypeCheck9.symbols new file mode 100644 index 00000000000..d820fb62ae8 --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck9.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts === +var union: string | string[] | number | symbol; +>union : Symbol(union, Decl(ES5For-ofTypeCheck9.ts, 0, 3)) + +for (let v of union) { } +>v : Symbol(v, Decl(ES5For-ofTypeCheck9.ts, 1, 8)) +>union : Symbol(union, Decl(ES5For-ofTypeCheck9.ts, 0, 3)) + diff --git a/tests/baselines/reference/ES5For-ofTypeCheck9.types b/tests/baselines/reference/ES5For-ofTypeCheck9.types new file mode 100644 index 00000000000..19c1c593d6e --- /dev/null +++ b/tests/baselines/reference/ES5For-ofTypeCheck9.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts === +var union: string | string[] | number | symbol; +>union : string | number | symbol | string[] + +for (let v of union) { } +>v : string +>union : string | number | symbol | string[] + diff --git a/tests/baselines/reference/ES5SymbolProperty1.symbols b/tests/baselines/reference/ES5SymbolProperty1.symbols new file mode 100644 index 00000000000..134b0df8e17 --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty1.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty1.ts === +interface SymbolConstructor { +>SymbolConstructor : Symbol(SymbolConstructor, Decl(ES5SymbolProperty1.ts, 0, 0)) + + foo: string; +>foo : Symbol(SymbolConstructor.foo, Decl(ES5SymbolProperty1.ts, 0, 29)) +} +var Symbol: SymbolConstructor; +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty1.ts, 3, 3)) +>SymbolConstructor : Symbol(SymbolConstructor, Decl(ES5SymbolProperty1.ts, 0, 0)) + +var obj = { +>obj : Symbol(obj, Decl(ES5SymbolProperty1.ts, 5, 3)) + + [Symbol.foo]: 0 +>Symbol.foo : Symbol(SymbolConstructor.foo, Decl(ES5SymbolProperty1.ts, 0, 29)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty1.ts, 3, 3)) +>foo : Symbol(SymbolConstructor.foo, Decl(ES5SymbolProperty1.ts, 0, 29)) +} + +obj[Symbol.foo]; +>obj : Symbol(obj, Decl(ES5SymbolProperty1.ts, 5, 3)) +>Symbol.foo : Symbol(SymbolConstructor.foo, Decl(ES5SymbolProperty1.ts, 0, 29)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty1.ts, 3, 3)) +>foo : Symbol(SymbolConstructor.foo, Decl(ES5SymbolProperty1.ts, 0, 29)) + diff --git a/tests/baselines/reference/ES5SymbolProperty1.types b/tests/baselines/reference/ES5SymbolProperty1.types new file mode 100644 index 00000000000..13cf5ae85b5 --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty1.types @@ -0,0 +1,29 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty1.ts === +interface SymbolConstructor { +>SymbolConstructor : SymbolConstructor + + foo: string; +>foo : string +} +var Symbol: SymbolConstructor; +>Symbol : SymbolConstructor +>SymbolConstructor : SymbolConstructor + +var obj = { +>obj : { [Symbol.foo]: number; } +>{ [Symbol.foo]: 0} : { [Symbol.foo]: number; } + + [Symbol.foo]: 0 +>Symbol.foo : string +>Symbol : SymbolConstructor +>foo : string +>0 : 0 +} + +obj[Symbol.foo]; +>obj[Symbol.foo] : any +>obj : { [Symbol.foo]: number; } +>Symbol.foo : string +>Symbol : SymbolConstructor +>foo : string + diff --git a/tests/baselines/reference/ES5SymbolProperty2.symbols b/tests/baselines/reference/ES5SymbolProperty2.symbols new file mode 100644 index 00000000000..4e784568baa --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty2.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty2.ts === +module M { +>M : Symbol(M, Decl(ES5SymbolProperty2.ts, 0, 0)) + + var Symbol: any; +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty2.ts, 1, 7)) + + export class C { +>C : Symbol(C, Decl(ES5SymbolProperty2.ts, 1, 20)) + + [Symbol.iterator]() { } +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty2.ts, 1, 7)) + } + (new C)[Symbol.iterator]; +>C : Symbol(C, Decl(ES5SymbolProperty2.ts, 1, 20)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty2.ts, 1, 7)) +} + +(new M.C)[Symbol.iterator]; +>M.C : Symbol(M.C, Decl(ES5SymbolProperty2.ts, 1, 20)) +>M : Symbol(M, Decl(ES5SymbolProperty2.ts, 0, 0)) +>C : Symbol(M.C, Decl(ES5SymbolProperty2.ts, 1, 20)) + diff --git a/tests/baselines/reference/ES5SymbolProperty2.types b/tests/baselines/reference/ES5SymbolProperty2.types new file mode 100644 index 00000000000..bea1ad72b6e --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty2.types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty2.ts === +module M { +>M : typeof M + + var Symbol: any; +>Symbol : any + + export class C { +>C : C + + [Symbol.iterator]() { } +>Symbol.iterator : any +>Symbol : any +>iterator : any + } + (new C)[Symbol.iterator]; +>(new C)[Symbol.iterator] : any +>(new C) : C +>new C : C +>C : typeof C +>Symbol.iterator : any +>Symbol : any +>iterator : any +} + +(new M.C)[Symbol.iterator]; +>(new M.C)[Symbol.iterator] : any +>(new M.C) : M.C +>new M.C : M.C +>M.C : typeof M.C +>M : typeof M +>C : typeof M.C +>Symbol.iterator : any +>Symbol : any +>iterator : any + diff --git a/tests/baselines/reference/ES5SymbolProperty3.symbols b/tests/baselines/reference/ES5SymbolProperty3.symbols new file mode 100644 index 00000000000..8d6ee1fb607 --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty3.symbols @@ -0,0 +1,15 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty3.ts === +var Symbol: any; +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty3.ts, 0, 3)) + +class C { +>C : Symbol(C, Decl(ES5SymbolProperty3.ts, 0, 16)) + + [Symbol.iterator]() { } +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty3.ts, 0, 3)) +} + +(new C)[Symbol.iterator] +>C : Symbol(C, Decl(ES5SymbolProperty3.ts, 0, 16)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty3.ts, 0, 3)) + diff --git a/tests/baselines/reference/ES5SymbolProperty3.types b/tests/baselines/reference/ES5SymbolProperty3.types new file mode 100644 index 00000000000..1a339a88c7c --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty3.types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty3.ts === +var Symbol: any; +>Symbol : any + +class C { +>C : C + + [Symbol.iterator]() { } +>Symbol.iterator : any +>Symbol : any +>iterator : any +} + +(new C)[Symbol.iterator] +>(new C)[Symbol.iterator] : any +>(new C) : C +>new C : C +>C : typeof C +>Symbol.iterator : any +>Symbol : any +>iterator : any + diff --git a/tests/baselines/reference/ES5SymbolProperty4.symbols b/tests/baselines/reference/ES5SymbolProperty4.symbols new file mode 100644 index 00000000000..feb3ab8153a --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty4.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty4.ts === +var Symbol: { iterator: string }; +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty4.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty4.ts, 0, 13)) + +class C { +>C : Symbol(C, Decl(ES5SymbolProperty4.ts, 0, 33)) + + [Symbol.iterator]() { } +>Symbol.iterator : Symbol(iterator, Decl(ES5SymbolProperty4.ts, 0, 13)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty4.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty4.ts, 0, 13)) +} + +(new C)[Symbol.iterator] +>C : Symbol(C, Decl(ES5SymbolProperty4.ts, 0, 33)) +>Symbol.iterator : Symbol(iterator, Decl(ES5SymbolProperty4.ts, 0, 13)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty4.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty4.ts, 0, 13)) + diff --git a/tests/baselines/reference/ES5SymbolProperty4.types b/tests/baselines/reference/ES5SymbolProperty4.types new file mode 100644 index 00000000000..98ab97d5888 --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty4.types @@ -0,0 +1,23 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty4.ts === +var Symbol: { iterator: string }; +>Symbol : { iterator: string; } +>iterator : string + +class C { +>C : C + + [Symbol.iterator]() { } +>Symbol.iterator : string +>Symbol : { iterator: string; } +>iterator : string +} + +(new C)[Symbol.iterator] +>(new C)[Symbol.iterator] : any +>(new C) : C +>new C : C +>C : typeof C +>Symbol.iterator : string +>Symbol : { iterator: string; } +>iterator : string + diff --git a/tests/baselines/reference/ES5SymbolProperty5.symbols b/tests/baselines/reference/ES5SymbolProperty5.symbols new file mode 100644 index 00000000000..30c3f31ca0b --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty5.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty5.ts === +var Symbol: { iterator: symbol }; +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty5.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty5.ts, 0, 13)) + +class C { +>C : Symbol(C, Decl(ES5SymbolProperty5.ts, 0, 33)) + + [Symbol.iterator]() { } +>Symbol.iterator : Symbol(iterator, Decl(ES5SymbolProperty5.ts, 0, 13)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty5.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty5.ts, 0, 13)) +} + +(new C)[Symbol.iterator](0) // Should error +>C : Symbol(C, Decl(ES5SymbolProperty5.ts, 0, 33)) +>Symbol.iterator : Symbol(iterator, Decl(ES5SymbolProperty5.ts, 0, 13)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty5.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty5.ts, 0, 13)) + diff --git a/tests/baselines/reference/ES5SymbolProperty5.types b/tests/baselines/reference/ES5SymbolProperty5.types new file mode 100644 index 00000000000..1e15b6b487f --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty5.types @@ -0,0 +1,25 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty5.ts === +var Symbol: { iterator: symbol }; +>Symbol : { iterator: symbol; } +>iterator : symbol + +class C { +>C : C + + [Symbol.iterator]() { } +>Symbol.iterator : symbol +>Symbol : { iterator: symbol; } +>iterator : symbol +} + +(new C)[Symbol.iterator](0) // Should error +>(new C)[Symbol.iterator](0) : void +>(new C)[Symbol.iterator] : () => void +>(new C) : C +>new C : C +>C : typeof C +>Symbol.iterator : symbol +>Symbol : { iterator: symbol; } +>iterator : symbol +>0 : 0 + diff --git a/tests/baselines/reference/ES5SymbolProperty6.symbols b/tests/baselines/reference/ES5SymbolProperty6.symbols new file mode 100644 index 00000000000..bb2d23e0c1e --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty6.ts === +class C { +>C : Symbol(C, Decl(ES5SymbolProperty6.ts, 0, 0)) + + [Symbol.iterator]() { } +} + +(new C)[Symbol.iterator] +>C : Symbol(C, Decl(ES5SymbolProperty6.ts, 0, 0)) + diff --git a/tests/baselines/reference/ES5SymbolProperty6.types b/tests/baselines/reference/ES5SymbolProperty6.types new file mode 100644 index 00000000000..45ac7c31c7b --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty6.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty6.ts === +class C { +>C : C + + [Symbol.iterator]() { } +>Symbol.iterator : any +>Symbol : any +>iterator : any +} + +(new C)[Symbol.iterator] +>(new C)[Symbol.iterator] : any +>(new C) : C +>new C : C +>C : typeof C +>Symbol.iterator : any +>Symbol : any +>iterator : any + diff --git a/tests/baselines/reference/ES5SymbolProperty7.symbols b/tests/baselines/reference/ES5SymbolProperty7.symbols new file mode 100644 index 00000000000..336d79e7356 --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty7.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty7.ts === +var Symbol: { iterator: any }; +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty7.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty7.ts, 0, 13)) + +class C { +>C : Symbol(C, Decl(ES5SymbolProperty7.ts, 0, 30)) + + [Symbol.iterator]() { } +>Symbol.iterator : Symbol(iterator, Decl(ES5SymbolProperty7.ts, 0, 13)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty7.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty7.ts, 0, 13)) +} + +(new C)[Symbol.iterator] +>C : Symbol(C, Decl(ES5SymbolProperty7.ts, 0, 30)) +>Symbol.iterator : Symbol(iterator, Decl(ES5SymbolProperty7.ts, 0, 13)) +>Symbol : Symbol(Symbol, Decl(ES5SymbolProperty7.ts, 0, 3)) +>iterator : Symbol(iterator, Decl(ES5SymbolProperty7.ts, 0, 13)) + diff --git a/tests/baselines/reference/ES5SymbolProperty7.types b/tests/baselines/reference/ES5SymbolProperty7.types new file mode 100644 index 00000000000..b0adad6cf13 --- /dev/null +++ b/tests/baselines/reference/ES5SymbolProperty7.types @@ -0,0 +1,23 @@ +=== tests/cases/conformance/Symbols/ES5SymbolProperty7.ts === +var Symbol: { iterator: any }; +>Symbol : { iterator: any; } +>iterator : any + +class C { +>C : C + + [Symbol.iterator]() { } +>Symbol.iterator : any +>Symbol : { iterator: any; } +>iterator : any +} + +(new C)[Symbol.iterator] +>(new C)[Symbol.iterator] : any +>(new C) : C +>new C : C +>C : typeof C +>Symbol.iterator : any +>Symbol : { iterator: any; } +>iterator : any + diff --git a/tests/baselines/reference/ExportAssignment7.symbols b/tests/baselines/reference/ExportAssignment7.symbols new file mode 100644 index 00000000000..162c9c2911e --- /dev/null +++ b/tests/baselines/reference/ExportAssignment7.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/ExportAssignment7.ts === +export class C { +>C : Symbol(C, Decl(ExportAssignment7.ts, 0, 0)) +} + +export = B; diff --git a/tests/baselines/reference/ExportAssignment7.types b/tests/baselines/reference/ExportAssignment7.types new file mode 100644 index 00000000000..2f0871f48a5 --- /dev/null +++ b/tests/baselines/reference/ExportAssignment7.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ExportAssignment7.ts === +export class C { +>C : C +} + +export = B; +>B : No type information available! + diff --git a/tests/baselines/reference/ExportAssignment8.symbols b/tests/baselines/reference/ExportAssignment8.symbols new file mode 100644 index 00000000000..771de032de7 --- /dev/null +++ b/tests/baselines/reference/ExportAssignment8.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/ExportAssignment8.ts === +export = B; + +export class C { +>C : Symbol(C, Decl(ExportAssignment8.ts, 0, 11)) +} diff --git a/tests/baselines/reference/ExportAssignment8.types b/tests/baselines/reference/ExportAssignment8.types new file mode 100644 index 00000000000..1b141b0b216 --- /dev/null +++ b/tests/baselines/reference/ExportAssignment8.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ExportAssignment8.ts === +export = B; +>B : No type information available! + +export class C { +>C : C +} diff --git a/tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.symbols b/tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.symbols new file mode 100644 index 00000000000..19c587f7148 --- /dev/null +++ b/tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.symbols @@ -0,0 +1,111 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts === +module A { +>A : Symbol(A, Decl(function.ts, 0, 0), Decl(module.ts, 0, 0)) + + export function Point() { +>Point : Symbol(Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) + + return { x: 0, y: 0 }; +>x : Symbol(x, Decl(function.ts, 2, 16)) +>y : Symbol(y, Decl(function.ts, 2, 22)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module A { +>A : Symbol(A, Decl(function.ts, 0, 0), Decl(module.ts, 0, 0)) + + export module Point { +>Point : Symbol(Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) + + export var Origin = { x: 0, y: 0 }; +>Origin : Symbol(Origin, Decl(module.ts, 2, 18)) +>x : Symbol(x, Decl(module.ts, 2, 29)) +>y : Symbol(y, Decl(module.ts, 2, 35)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts === +var fn: () => { x: number; y: number }; +>fn : Symbol(fn, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(simple.ts, 11, 3), Decl(simple.ts, 12, 3)) +>x : Symbol(x, Decl(test.ts, 0, 15)) +>y : Symbol(y, Decl(test.ts, 0, 26)) + +var fn = A.Point; +>fn : Symbol(fn, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(simple.ts, 11, 3), Decl(simple.ts, 12, 3)) +>A.Point : Symbol(A.Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) +>A : Symbol(A, Decl(function.ts, 0, 0), Decl(module.ts, 0, 0)) +>Point : Symbol(A.Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) + +var cl: { x: number; y: number; } +>cl : Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3), Decl(test.ts, 5, 3), Decl(simple.ts, 14, 3), Decl(simple.ts, 15, 3) ... and 1 more) +>x : Symbol(x, Decl(test.ts, 3, 9)) +>y : Symbol(y, Decl(test.ts, 3, 20)) + +var cl = A.Point(); +>cl : Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3), Decl(test.ts, 5, 3), Decl(simple.ts, 14, 3), Decl(simple.ts, 15, 3) ... and 1 more) +>A.Point : Symbol(A.Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) +>A : Symbol(A, Decl(function.ts, 0, 0), Decl(module.ts, 0, 0)) +>Point : Symbol(A.Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) + +var cl = A.Point.Origin; // not expected to be an error. +>cl : Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3), Decl(test.ts, 5, 3), Decl(simple.ts, 14, 3), Decl(simple.ts, 15, 3) ... and 1 more) +>A.Point.Origin : Symbol(A.Point.Origin, Decl(module.ts, 2, 18)) +>A.Point : Symbol(A.Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) +>A : Symbol(A, Decl(function.ts, 0, 0), Decl(module.ts, 0, 0)) +>Point : Symbol(A.Point, Decl(function.ts, 0, 10), Decl(module.ts, 0, 10)) +>Origin : Symbol(A.Point.Origin, Decl(module.ts, 2, 18)) + + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +module B { +>B : Symbol(B, Decl(simple.ts, 0, 0)) + + export function Point() { +>Point : Symbol(Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) + + return { x: 0, y: 0 }; +>x : Symbol(x, Decl(simple.ts, 3, 16)) +>y : Symbol(y, Decl(simple.ts, 3, 22)) + } + + export module Point { +>Point : Symbol(Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) + + export var Origin = { x: 0, y: 0 }; +>Origin : Symbol(Origin, Decl(simple.ts, 7, 18)) +>x : Symbol(x, Decl(simple.ts, 7, 29)) +>y : Symbol(y, Decl(simple.ts, 7, 35)) + } +} + +var fn: () => { x: number; y: number }; +>fn : Symbol(fn, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(simple.ts, 11, 3), Decl(simple.ts, 12, 3)) +>x : Symbol(x, Decl(simple.ts, 11, 15)) +>y : Symbol(y, Decl(simple.ts, 11, 26)) + +var fn = B.Point; // not expected to be an error. bug 840000: [corelang] Function of fundule not assignalbe as expected +>fn : Symbol(fn, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(simple.ts, 11, 3), Decl(simple.ts, 12, 3)) +>B.Point : Symbol(B.Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) +>B : Symbol(B, Decl(simple.ts, 0, 0)) +>Point : Symbol(B.Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) + +var cl: { x: number; y: number; } +>cl : Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3), Decl(test.ts, 5, 3), Decl(simple.ts, 14, 3), Decl(simple.ts, 15, 3) ... and 1 more) +>x : Symbol(x, Decl(simple.ts, 14, 9)) +>y : Symbol(y, Decl(simple.ts, 14, 20)) + +var cl = B.Point(); +>cl : Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3), Decl(test.ts, 5, 3), Decl(simple.ts, 14, 3), Decl(simple.ts, 15, 3) ... and 1 more) +>B.Point : Symbol(B.Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) +>B : Symbol(B, Decl(simple.ts, 0, 0)) +>Point : Symbol(B.Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) + +var cl = B.Point.Origin; +>cl : Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3), Decl(test.ts, 5, 3), Decl(simple.ts, 14, 3), Decl(simple.ts, 15, 3) ... and 1 more) +>B.Point.Origin : Symbol(B.Point.Origin, Decl(simple.ts, 7, 18)) +>B.Point : Symbol(B.Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) +>B : Symbol(B, Decl(simple.ts, 0, 0)) +>Point : Symbol(B.Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) +>Origin : Symbol(B.Point.Origin, Decl(simple.ts, 7, 18)) + diff --git a/tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.types b/tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.types new file mode 100644 index 00000000000..a38a459f9e5 --- /dev/null +++ b/tests/baselines/reference/FunctionAndModuleWithSameNameAndCommonRoot.types @@ -0,0 +1,125 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts === +module A { +>A : typeof A + + export function Point() { +>Point : typeof Point + + return { x: 0, y: 0 }; +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module A { +>A : typeof A + + export module Point { +>Point : typeof Point + + export var Origin = { x: 0, y: 0 }; +>Origin : { x: number; y: number; } +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts === +var fn: () => { x: number; y: number }; +>fn : () => { x: number; y: number; } +>x : number +>y : number + +var fn = A.Point; +>fn : () => { x: number; y: number; } +>A.Point : typeof A.Point +>A : typeof A +>Point : typeof A.Point + +var cl: { x: number; y: number; } +>cl : { x: number; y: number; } +>x : number +>y : number + +var cl = A.Point(); +>cl : { x: number; y: number; } +>A.Point() : { x: number; y: number; } +>A.Point : typeof A.Point +>A : typeof A +>Point : typeof A.Point + +var cl = A.Point.Origin; // not expected to be an error. +>cl : { x: number; y: number; } +>A.Point.Origin : { x: number; y: number; } +>A.Point : typeof A.Point +>A : typeof A +>Point : typeof A.Point +>Origin : { x: number; y: number; } + + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +module B { +>B : typeof B + + export function Point() { +>Point : typeof Point + + return { x: 0, y: 0 }; +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } + + export module Point { +>Point : typeof Point + + export var Origin = { x: 0, y: 0 }; +>Origin : { x: number; y: number; } +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } +} + +var fn: () => { x: number; y: number }; +>fn : () => { x: number; y: number; } +>x : number +>y : number + +var fn = B.Point; // not expected to be an error. bug 840000: [corelang] Function of fundule not assignalbe as expected +>fn : () => { x: number; y: number; } +>B.Point : typeof B.Point +>B : typeof B +>Point : typeof B.Point + +var cl: { x: number; y: number; } +>cl : { x: number; y: number; } +>x : number +>y : number + +var cl = B.Point(); +>cl : { x: number; y: number; } +>B.Point() : { x: number; y: number; } +>B.Point : typeof B.Point +>B : typeof B +>Point : typeof B.Point + +var cl = B.Point.Origin; +>cl : { x: number; y: number; } +>B.Point.Origin : { x: number; y: number; } +>B.Point : typeof B.Point +>B : typeof B +>Point : typeof B.Point +>Origin : { x: number; y: number; } + diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.symbols b/tests/baselines/reference/FunctionDeclaration10_es6.symbols new file mode 100644 index 00000000000..2b1ccb2a636 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration10_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts === +function * foo(a = yield => yield) { +>foo : Symbol(foo, Decl(FunctionDeclaration10_es6.ts, 0, 0)) +>a : Symbol(a, Decl(FunctionDeclaration10_es6.ts, 0, 15)) +} diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.types b/tests/baselines/reference/FunctionDeclaration10_es6.types new file mode 100644 index 00000000000..2bd25f5a630 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration10_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration10_es6.ts === +function * foo(a = yield => yield) { +>foo : (a?: any) => any +>a : any +>yield : any +>yield : any +} diff --git a/tests/baselines/reference/FunctionDeclaration12_es6.symbols b/tests/baselines/reference/FunctionDeclaration12_es6.symbols new file mode 100644 index 00000000000..d2bdccc179e --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration12_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration12_es6.ts === +var v = function * yield() { } +>v : Symbol(v, Decl(FunctionDeclaration12_es6.ts, 0, 3)) +>yield : Symbol(yield, Decl(FunctionDeclaration12_es6.ts, 0, 18)) + diff --git a/tests/baselines/reference/FunctionDeclaration12_es6.types b/tests/baselines/reference/FunctionDeclaration12_es6.types new file mode 100644 index 00000000000..5d413f99d07 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration12_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration12_es6.ts === +var v = function * yield() { } +>v : () => any +>function * : () => any +>yield : () => void +>() { } : () => void + diff --git a/tests/baselines/reference/FunctionDeclaration13_es6.symbols b/tests/baselines/reference/FunctionDeclaration13_es6.symbols new file mode 100644 index 00000000000..ad40b5623bb --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration13_es6.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts === +function * foo() { +>foo : Symbol(foo, Decl(FunctionDeclaration13_es6.ts, 0, 0)) + + // Legal to use 'yield' in a type context. + var v: yield; +>v : Symbol(v, Decl(FunctionDeclaration13_es6.ts, 2, 6)) +} + diff --git a/tests/baselines/reference/FunctionDeclaration13_es6.types b/tests/baselines/reference/FunctionDeclaration13_es6.types new file mode 100644 index 00000000000..69502a3e37c --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration13_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts === +function * foo() { +>foo : () => IterableIterator + + // Legal to use 'yield' in a type context. + var v: yield; +>v : any +>yield : No type information available! +} + diff --git a/tests/baselines/reference/FunctionDeclaration3.symbols b/tests/baselines/reference/FunctionDeclaration3.symbols new file mode 100644 index 00000000000..1bc408ca323 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration3.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/FunctionDeclaration3.ts === +function foo(); +>foo : Symbol(foo, Decl(FunctionDeclaration3.ts, 0, 0)) + diff --git a/tests/baselines/reference/FunctionDeclaration3.types b/tests/baselines/reference/FunctionDeclaration3.types new file mode 100644 index 00000000000..8f528adc9ce --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration3.types @@ -0,0 +1,4 @@ +=== tests/cases/compiler/FunctionDeclaration3.ts === +function foo(); +>foo : () => any + diff --git a/tests/baselines/reference/FunctionDeclaration3_es6.symbols b/tests/baselines/reference/FunctionDeclaration3_es6.symbols new file mode 100644 index 00000000000..3a797233a47 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration3_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration3_es6.ts === +function f(yield = yield) { +>f : Symbol(f, Decl(FunctionDeclaration3_es6.ts, 0, 0)) +>yield : Symbol(yield, Decl(FunctionDeclaration3_es6.ts, 0, 11)) +>yield : Symbol(yield, Decl(FunctionDeclaration3_es6.ts, 0, 11)) +} diff --git a/tests/baselines/reference/FunctionDeclaration3_es6.types b/tests/baselines/reference/FunctionDeclaration3_es6.types new file mode 100644 index 00000000000..ce1e58e34b6 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration3_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration3_es6.ts === +function f(yield = yield) { +>f : (yield?: any) => void +>yield : any +>yield : any +} diff --git a/tests/baselines/reference/FunctionDeclaration4.symbols b/tests/baselines/reference/FunctionDeclaration4.symbols new file mode 100644 index 00000000000..1e22e10cbe5 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration4.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/FunctionDeclaration4.ts === +function foo(); +>foo : Symbol(foo, Decl(FunctionDeclaration4.ts, 0, 0)) + +function bar() { } +>bar : Symbol(bar, Decl(FunctionDeclaration4.ts, 0, 15)) + diff --git a/tests/baselines/reference/FunctionDeclaration4.types b/tests/baselines/reference/FunctionDeclaration4.types new file mode 100644 index 00000000000..ee6d57880cc --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration4.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/FunctionDeclaration4.ts === +function foo(); +>foo : () => any + +function bar() { } +>bar : () => void + diff --git a/tests/baselines/reference/FunctionDeclaration5_es6.symbols b/tests/baselines/reference/FunctionDeclaration5_es6.symbols new file mode 100644 index 00000000000..67732f518e5 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration5_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration5_es6.ts === +function*foo(yield) { +>foo : Symbol(foo, Decl(FunctionDeclaration5_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/FunctionDeclaration5_es6.types b/tests/baselines/reference/FunctionDeclaration5_es6.types new file mode 100644 index 00000000000..9478988e7ea --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration5_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration5_es6.ts === +function*foo(yield) { +>foo : () => any +>yield : any +} diff --git a/tests/baselines/reference/FunctionDeclaration6.symbols b/tests/baselines/reference/FunctionDeclaration6.symbols new file mode 100644 index 00000000000..d8c66e83985 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/FunctionDeclaration6.ts === +{ + function foo(); +>foo : Symbol(foo, Decl(FunctionDeclaration6.ts, 0, 1)) + + function bar() { } +>bar : Symbol(bar, Decl(FunctionDeclaration6.ts, 1, 19)) +} diff --git a/tests/baselines/reference/FunctionDeclaration6.types b/tests/baselines/reference/FunctionDeclaration6.types new file mode 100644 index 00000000000..d3d135a6cfa --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration6.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/FunctionDeclaration6.ts === +{ + function foo(); +>foo : () => any + + function bar() { } +>bar : () => void +} diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.symbols b/tests/baselines/reference/FunctionDeclaration6_es6.symbols new file mode 100644 index 00000000000..36d4624da42 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration6_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts === +function*foo(a = yield) { +>foo : Symbol(foo, Decl(FunctionDeclaration6_es6.ts, 0, 0)) +>a : Symbol(a, Decl(FunctionDeclaration6_es6.ts, 0, 13)) +} diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.types b/tests/baselines/reference/FunctionDeclaration6_es6.types new file mode 100644 index 00000000000..4cfb710a781 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration6_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts === +function*foo(a = yield) { +>foo : (a?: any) => IterableIterator +>a : any +>yield : any +} diff --git a/tests/baselines/reference/FunctionDeclaration7.symbols b/tests/baselines/reference/FunctionDeclaration7.symbols new file mode 100644 index 00000000000..65199406fea --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration7.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/FunctionDeclaration7.ts === +module M { +>M : Symbol(M, Decl(FunctionDeclaration7.ts, 0, 0)) + + function foo(); +>foo : Symbol(foo, Decl(FunctionDeclaration7.ts, 0, 10)) +} diff --git a/tests/baselines/reference/FunctionDeclaration7.types b/tests/baselines/reference/FunctionDeclaration7.types new file mode 100644 index 00000000000..3142431e4d7 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration7.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/FunctionDeclaration7.ts === +module M { +>M : typeof M + + function foo(); +>foo : () => any +} diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.symbols b/tests/baselines/reference/FunctionDeclaration7_es6.symbols new file mode 100644 index 00000000000..dc15ae760cd --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration7_es6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts === +function*bar() { +>bar : Symbol(bar, Decl(FunctionDeclaration7_es6.ts, 0, 0)) + + // 'yield' here is an identifier, and not a yield expression. + function*foo(a = yield) { +>foo : Symbol(foo, Decl(FunctionDeclaration7_es6.ts, 0, 16)) +>a : Symbol(a, Decl(FunctionDeclaration7_es6.ts, 2, 15)) + } +} diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.types b/tests/baselines/reference/FunctionDeclaration7_es6.types new file mode 100644 index 00000000000..d9635231e4a --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration7_es6.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts === +function*bar() { +>bar : () => IterableIterator + + // 'yield' here is an identifier, and not a yield expression. + function*foo(a = yield) { +>foo : (a?: any) => IterableIterator +>a : any +>yield : any + } +} diff --git a/tests/baselines/reference/FunctionDeclaration8_es6.symbols b/tests/baselines/reference/FunctionDeclaration8_es6.symbols new file mode 100644 index 00000000000..037983e8a21 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration8_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts === +var v = { [yield]: foo } +>v : Symbol(v, Decl(FunctionDeclaration8_es6.ts, 0, 3)) + diff --git a/tests/baselines/reference/FunctionDeclaration8_es6.types b/tests/baselines/reference/FunctionDeclaration8_es6.types new file mode 100644 index 00000000000..0d3056053d2 --- /dev/null +++ b/tests/baselines/reference/FunctionDeclaration8_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts === +var v = { [yield]: foo } +>v : { [x: number]: any; } +>{ [yield]: foo } : { [x: number]: any; } +>yield : any +>foo : any + diff --git a/tests/baselines/reference/FunctionPropertyAssignments2_es6.symbols b/tests/baselines/reference/FunctionPropertyAssignments2_es6.symbols new file mode 100644 index 00000000000..ac135affbb6 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments2_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments2_es6.ts === +var v = { *() { } } +>v : Symbol(v, Decl(FunctionPropertyAssignments2_es6.ts, 0, 3)) +> : Symbol((Missing), Decl(FunctionPropertyAssignments2_es6.ts, 0, 9)) + diff --git a/tests/baselines/reference/FunctionPropertyAssignments2_es6.types b/tests/baselines/reference/FunctionPropertyAssignments2_es6.types new file mode 100644 index 00000000000..6b9a2da9408 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments2_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments2_es6.ts === +var v = { *() { } } +>v : { (Missing)(): IterableIterator; } +>{ *() { } } : { (Missing)(): IterableIterator; } +> : () => IterableIterator + diff --git a/tests/baselines/reference/FunctionPropertyAssignments3_es6.symbols b/tests/baselines/reference/FunctionPropertyAssignments3_es6.symbols new file mode 100644 index 00000000000..e16ef01c957 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments3_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments3_es6.ts === +var v = { *{ } } +>v : Symbol(v, Decl(FunctionPropertyAssignments3_es6.ts, 0, 3)) +> : Symbol((Missing), Decl(FunctionPropertyAssignments3_es6.ts, 0, 9)) + diff --git a/tests/baselines/reference/FunctionPropertyAssignments3_es6.types b/tests/baselines/reference/FunctionPropertyAssignments3_es6.types new file mode 100644 index 00000000000..9222f6e142d --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments3_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments3_es6.ts === +var v = { *{ } } +>v : { (Missing)(): IterableIterator; } +>{ *{ } } : { (Missing)(): IterableIterator; } +> : () => IterableIterator + diff --git a/tests/baselines/reference/FunctionPropertyAssignments4_es6.symbols b/tests/baselines/reference/FunctionPropertyAssignments4_es6.symbols new file mode 100644 index 00000000000..6b9754f9b50 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments4_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments4_es6.ts === +var v = { * } +>v : Symbol(v, Decl(FunctionPropertyAssignments4_es6.ts, 0, 3)) +> : Symbol((Missing), Decl(FunctionPropertyAssignments4_es6.ts, 0, 9)) + diff --git a/tests/baselines/reference/FunctionPropertyAssignments4_es6.types b/tests/baselines/reference/FunctionPropertyAssignments4_es6.types new file mode 100644 index 00000000000..f244fd4fb33 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments4_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments4_es6.ts === +var v = { * } +>v : { (Missing)(): any; } +>{ * } : { (Missing)(): any; } +> : () => any + diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.symbols b/tests/baselines/reference/FunctionPropertyAssignments5_es6.symbols new file mode 100644 index 00000000000..f5746daa2ec --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts === +var v = { *[foo()]() { } } +>v : Symbol(v, Decl(FunctionPropertyAssignments5_es6.ts, 0, 3)) + diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.types b/tests/baselines/reference/FunctionPropertyAssignments5_es6.types new file mode 100644 index 00000000000..e2ff6419bf9 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts === +var v = { *[foo()]() { } } +>v : { [x: number]: () => IterableIterator; } +>{ *[foo()]() { } } : { [x: number]: () => IterableIterator; } +>foo() : any +>foo : any + diff --git a/tests/baselines/reference/FunctionPropertyAssignments6_es6.symbols b/tests/baselines/reference/FunctionPropertyAssignments6_es6.symbols new file mode 100644 index 00000000000..b7e08ae0ed4 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments6_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments6_es6.ts === +var v = { *() { } } +>v : Symbol(v, Decl(FunctionPropertyAssignments6_es6.ts, 0, 3)) +> : Symbol((Missing), Decl(FunctionPropertyAssignments6_es6.ts, 0, 9)) +>T : Symbol(T, Decl(FunctionPropertyAssignments6_es6.ts, 0, 12)) + diff --git a/tests/baselines/reference/FunctionPropertyAssignments6_es6.types b/tests/baselines/reference/FunctionPropertyAssignments6_es6.types new file mode 100644 index 00000000000..050d97df735 --- /dev/null +++ b/tests/baselines/reference/FunctionPropertyAssignments6_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments6_es6.ts === +var v = { *() { } } +>v : { (Missing)(): IterableIterator; } +>{ *() { } } : { (Missing)(): IterableIterator; } +> : () => IterableIterator +>T : T + diff --git a/tests/baselines/reference/InterfaceDeclaration8.symbols b/tests/baselines/reference/InterfaceDeclaration8.symbols new file mode 100644 index 00000000000..cf57f53c899 --- /dev/null +++ b/tests/baselines/reference/InterfaceDeclaration8.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/InterfaceDeclaration8.ts === +interface string { +>string : Symbol(string, Decl(InterfaceDeclaration8.ts, 0, 0)) +} diff --git a/tests/baselines/reference/InterfaceDeclaration8.types b/tests/baselines/reference/InterfaceDeclaration8.types new file mode 100644 index 00000000000..d65b6376457 --- /dev/null +++ b/tests/baselines/reference/InterfaceDeclaration8.types @@ -0,0 +1,4 @@ +=== tests/cases/compiler/InterfaceDeclaration8.ts === +interface string { +>string : string +} diff --git a/tests/baselines/reference/InvalidNonInstantiatedModule.symbols b/tests/baselines/reference/InvalidNonInstantiatedModule.symbols new file mode 100644 index 00000000000..1fd5f0839a2 --- /dev/null +++ b/tests/baselines/reference/InvalidNonInstantiatedModule.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts === +module M { +>M : Symbol(M, Decl(InvalidNonInstantiatedModule.ts, 0, 0)) + + export interface Point { x: number; y: number } +>Point : Symbol(Point, Decl(InvalidNonInstantiatedModule.ts, 0, 10)) +>x : Symbol(Point.x, Decl(InvalidNonInstantiatedModule.ts, 1, 28)) +>y : Symbol(Point.y, Decl(InvalidNonInstantiatedModule.ts, 1, 39)) +} + +var m = M; // Error, not instantiated can not be used as var +>m : Symbol(m, Decl(InvalidNonInstantiatedModule.ts, 4, 3)) + +var x: typeof M; // Error only a namespace +>x : Symbol(x, Decl(InvalidNonInstantiatedModule.ts, 6, 3)) + diff --git a/tests/baselines/reference/InvalidNonInstantiatedModule.types b/tests/baselines/reference/InvalidNonInstantiatedModule.types new file mode 100644 index 00000000000..28141c16ec8 --- /dev/null +++ b/tests/baselines/reference/InvalidNonInstantiatedModule.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/internalModules/moduleDeclarations/InvalidNonInstantiatedModule.ts === +module M { +>M : any + + export interface Point { x: number; y: number } +>Point : Point +>x : number +>y : number +} + +var m = M; // Error, not instantiated can not be used as var +>m : any +>M : any + +var x: typeof M; // Error only a namespace +>x : any +>M : any + diff --git a/tests/baselines/reference/MemberAccessorDeclaration15.symbols b/tests/baselines/reference/MemberAccessorDeclaration15.symbols new file mode 100644 index 00000000000..e7159a4f522 --- /dev/null +++ b/tests/baselines/reference/MemberAccessorDeclaration15.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/MemberAccessorDeclaration15.ts === +class C { +>C : Symbol(C, Decl(MemberAccessorDeclaration15.ts, 0, 0)) + + set Foo(public a: number) { } +>Foo : Symbol(C.Foo, Decl(MemberAccessorDeclaration15.ts, 0, 9)) +>a : Symbol(a, Decl(MemberAccessorDeclaration15.ts, 1, 11)) +} diff --git a/tests/baselines/reference/MemberAccessorDeclaration15.types b/tests/baselines/reference/MemberAccessorDeclaration15.types new file mode 100644 index 00000000000..78245827824 --- /dev/null +++ b/tests/baselines/reference/MemberAccessorDeclaration15.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/MemberAccessorDeclaration15.ts === +class C { +>C : C + + set Foo(public a: number) { } +>Foo : number +>a : number +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration3_es6.symbols new file mode 100644 index 00000000000..e2b8b39b363 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration3_es6.ts, 0, 0)) + + *[foo]() { } +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.types b/tests/baselines/reference/MemberFunctionDeclaration3_es6.types new file mode 100644 index 00000000000..fca123d15e6 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts === +class C { +>C : C + + *[foo]() { } +>foo : any +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration4_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration4_es6.symbols new file mode 100644 index 00000000000..151fd390621 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration4_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration4_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration4_es6.ts, 0, 0)) + + *() { } +> : Symbol(C[(Missing)], Decl(MemberFunctionDeclaration4_es6.ts, 0, 9)) +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration4_es6.types b/tests/baselines/reference/MemberFunctionDeclaration4_es6.types new file mode 100644 index 00000000000..7717c30a449 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration4_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration4_es6.ts === +class C { +>C : C + + *() { } +> : () => IterableIterator +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration5_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration5_es6.symbols new file mode 100644 index 00000000000..60879aadfe6 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration5_es6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration5_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration5_es6.ts, 0, 0)) + + * +} +> : Symbol(C[(Missing)], Decl(MemberFunctionDeclaration5_es6.ts, 0, 9)) + diff --git a/tests/baselines/reference/MemberFunctionDeclaration5_es6.types b/tests/baselines/reference/MemberFunctionDeclaration5_es6.types new file mode 100644 index 00000000000..12241a660c4 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration5_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration5_es6.ts === +class C { +>C : C + + * +} +> : () => any + diff --git a/tests/baselines/reference/MemberFunctionDeclaration6_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration6_es6.symbols new file mode 100644 index 00000000000..bbf4da338e7 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration6_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration6_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration6_es6.ts, 0, 0)) + + *foo +>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration6_es6.ts, 0, 9)) +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration6_es6.types b/tests/baselines/reference/MemberFunctionDeclaration6_es6.types new file mode 100644 index 00000000000..a74bd86b615 --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration6_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration6_es6.ts === +class C { +>C : C + + *foo +>foo : () => any +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols new file mode 100644 index 00000000000..0229450477c --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration8_es6.ts === +class C { +>C : Symbol(C, Decl(MemberFunctionDeclaration8_es6.ts, 0, 0)) + + foo() { +>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration8_es6.ts, 0, 9)) + + // Make sure we don't think of *bar as the start of a generator method. + if (a) # * bar; + return bar; + } +} diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.types b/tests/baselines/reference/MemberFunctionDeclaration8_es6.types new file mode 100644 index 00000000000..b0234b4135e --- /dev/null +++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration8_es6.ts === +class C { +>C : C + + foo() { +>foo : () => any + + // Make sure we don't think of *bar as the start of a generator method. + if (a) # * bar; +>a : any +> : any +>* bar : number +> : any +>bar : any + + return bar; +>bar : any + } +} diff --git a/tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.symbols b/tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.symbols new file mode 100644 index 00000000000..9d90d6dd3cc --- /dev/null +++ b/tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.symbols @@ -0,0 +1,64 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module X.Y { +>X : Symbol(X, Decl(module.ts, 0, 0), Decl(classPoint.ts, 0, 0)) +>Y : Symbol(Y, Decl(module.ts, 0, 9), Decl(classPoint.ts, 0, 9)) + + export module Point { +>Point : Symbol(Point, Decl(module.ts, 0, 12), Decl(classPoint.ts, 0, 12)) + + export var Origin = new Point(0, 0); +>Origin : Symbol(Origin, Decl(module.ts, 2, 18)) +>Point : Symbol(Point, Decl(module.ts, 0, 12), Decl(classPoint.ts, 0, 12)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts === +module X.Y { +>X : Symbol(X, Decl(module.ts, 0, 0), Decl(classPoint.ts, 0, 0)) +>Y : Symbol(Y, Decl(module.ts, 0, 9), Decl(classPoint.ts, 0, 9)) + + // duplicate identifier + export class Point { +>Point : Symbol(Point, Decl(module.ts, 0, 12), Decl(classPoint.ts, 0, 12)) + + constructor(x: number, y: number) { +>x : Symbol(x, Decl(classPoint.ts, 3, 20)) +>y : Symbol(y, Decl(classPoint.ts, 3, 30)) + + this.x = x; +>this.x : Symbol(Point.x, Decl(classPoint.ts, 6, 9)) +>this : Symbol(Point, Decl(module.ts, 0, 12), Decl(classPoint.ts, 0, 12)) +>x : Symbol(Point.x, Decl(classPoint.ts, 6, 9)) +>x : Symbol(x, Decl(classPoint.ts, 3, 20)) + + this.y = y; +>this.y : Symbol(Point.y, Decl(classPoint.ts, 7, 18)) +>this : Symbol(Point, Decl(module.ts, 0, 12), Decl(classPoint.ts, 0, 12)) +>y : Symbol(Point.y, Decl(classPoint.ts, 7, 18)) +>y : Symbol(y, Decl(classPoint.ts, 3, 30)) + } + x: number; +>x : Symbol(Point.x, Decl(classPoint.ts, 6, 9)) + + y: number; +>y : Symbol(Point.y, Decl(classPoint.ts, 7, 18)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +module A { +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + + export var Instance = new A(); +>Instance : Symbol(Instance, Decl(simple.ts, 1, 14)) +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) +} + +// duplicate identifier +class A { +>A : Symbol(A, Decl(simple.ts, 0, 0), Decl(simple.ts, 2, 1)) + + id: string; +>id : Symbol(A.id, Decl(simple.ts, 5, 9)) +} + diff --git a/tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.types b/tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.types new file mode 100644 index 00000000000..0041418426a --- /dev/null +++ b/tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.types @@ -0,0 +1,70 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module X.Y { +>X : typeof X +>Y : typeof Y + + export module Point { +>Point : typeof Point + + export var Origin = new Point(0, 0); +>Origin : Point +>new Point(0, 0) : Point +>Point : typeof Point +>0 : 0 +>0 : 0 + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts === +module X.Y { +>X : typeof X +>Y : typeof Y + + // duplicate identifier + export class Point { +>Point : Point + + constructor(x: number, y: number) { +>x : number +>y : number + + this.x = x; +>this.x = x : number +>this.x : number +>this : this +>x : number +>x : number + + this.y = y; +>this.y = y : number +>this.y : number +>this : this +>y : number +>y : number + } + x: number; +>x : number + + y: number; +>y : number + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +module A { +>A : typeof A + + export var Instance = new A(); +>Instance : A +>new A() : A +>A : typeof A +} + +// duplicate identifier +class A { +>A : A + + id: string; +>id : string +} + diff --git a/tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.symbols b/tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.symbols new file mode 100644 index 00000000000..84d2f4be3dc --- /dev/null +++ b/tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module A { +>A : Symbol(A, Decl(module.ts, 0, 0), Decl(function.ts, 0, 0)) + + export module Point { +>Point : Symbol(Point, Decl(module.ts, 0, 10), Decl(function.ts, 0, 10)) + + export var Origin = { x: 0, y: 0 }; +>Origin : Symbol(Origin, Decl(module.ts, 2, 18)) +>x : Symbol(x, Decl(module.ts, 2, 29)) +>y : Symbol(y, Decl(module.ts, 2, 35)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts === +module A { +>A : Symbol(A, Decl(module.ts, 0, 0), Decl(function.ts, 0, 0)) + + // duplicate identifier error + export function Point() { +>Point : Symbol(Point, Decl(module.ts, 0, 10), Decl(function.ts, 0, 10)) + + return { x: 0, y: 0 }; +>x : Symbol(x, Decl(function.ts, 3, 16)) +>y : Symbol(y, Decl(function.ts, 3, 22)) + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +module B { +>B : Symbol(B, Decl(simple.ts, 0, 0)) + + export module Point { +>Point : Symbol(Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) + + export var Origin = { x: 0, y: 0 }; +>Origin : Symbol(Origin, Decl(simple.ts, 3, 18)) +>x : Symbol(x, Decl(simple.ts, 3, 29)) +>y : Symbol(y, Decl(simple.ts, 3, 35)) + } + + // duplicate identifier error + export function Point() { +>Point : Symbol(Point, Decl(simple.ts, 0, 10), Decl(simple.ts, 4, 5)) + + return { x: 0, y: 0 }; +>x : Symbol(x, Decl(simple.ts, 8, 16)) +>y : Symbol(y, Decl(simple.ts, 8, 22)) + } +} + diff --git a/tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.types b/tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.types new file mode 100644 index 00000000000..ffa10552a03 --- /dev/null +++ b/tests/baselines/reference/ModuleAndFunctionWithSameNameAndCommonRoot.types @@ -0,0 +1,63 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts === +module A { +>A : typeof A + + export module Point { +>Point : typeof Point + + export var Origin = { x: 0, y: 0 }; +>Origin : { x: number; y: number; } +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts === +module A { +>A : typeof A + + // duplicate identifier error + export function Point() { +>Point : typeof Point + + return { x: 0, y: 0 }; +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/simple.ts === +module B { +>B : typeof B + + export module Point { +>Point : typeof Point + + export var Origin = { x: 0, y: 0 }; +>Origin : { x: number; y: number; } +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } + + // duplicate identifier error + export function Point() { +>Point : typeof Point + + return { x: 0, y: 0 }; +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + } +} + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.symbols b/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.symbols new file mode 100644 index 00000000000..54bf3dd70e4 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.symbols @@ -0,0 +1,81 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedClasses.ts === +module A { +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 0)) + + export class A { +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 10)) + + id: number; +>id : Symbol(A.id, Decl(ModuleWithExportedAndNonExportedClasses.ts, 1, 20)) + + name: string; +>name : Symbol(A.name, Decl(ModuleWithExportedAndNonExportedClasses.ts, 2, 19)) + } + + export class AG{ +>AG : Symbol(AG, Decl(ModuleWithExportedAndNonExportedClasses.ts, 4, 5)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedClasses.ts, 6, 20)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedClasses.ts, 6, 22)) + + id: T; +>id : Symbol(AG.id, Decl(ModuleWithExportedAndNonExportedClasses.ts, 6, 26)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedClasses.ts, 6, 20)) + + name: U; +>name : Symbol(AG.name, Decl(ModuleWithExportedAndNonExportedClasses.ts, 7, 14)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedClasses.ts, 6, 22)) + } + + class A2 { +>A2 : Symbol(A2, Decl(ModuleWithExportedAndNonExportedClasses.ts, 9, 5)) + + id: number; +>id : Symbol(A2.id, Decl(ModuleWithExportedAndNonExportedClasses.ts, 11, 14)) + + name: string; +>name : Symbol(A2.name, Decl(ModuleWithExportedAndNonExportedClasses.ts, 12, 19)) + } + + class AG2{ +>AG2 : Symbol(AG2, Decl(ModuleWithExportedAndNonExportedClasses.ts, 14, 5)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedClasses.ts, 16, 14)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedClasses.ts, 16, 16)) + + id: T; +>id : Symbol(AG2.id, Decl(ModuleWithExportedAndNonExportedClasses.ts, 16, 20)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedClasses.ts, 16, 14)) + + name: U; +>name : Symbol(AG2.name, Decl(ModuleWithExportedAndNonExportedClasses.ts, 17, 14)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedClasses.ts, 16, 16)) + } +} + +// no errors expected, these are all exported +var a: { id: number; name: string }; +>a : Symbol(a, Decl(ModuleWithExportedAndNonExportedClasses.ts, 23, 3), Decl(ModuleWithExportedAndNonExportedClasses.ts, 24, 3)) +>id : Symbol(id, Decl(ModuleWithExportedAndNonExportedClasses.ts, 23, 8)) +>name : Symbol(name, Decl(ModuleWithExportedAndNonExportedClasses.ts, 23, 20)) + +var a = new A.A(); +>a : Symbol(a, Decl(ModuleWithExportedAndNonExportedClasses.ts, 23, 3), Decl(ModuleWithExportedAndNonExportedClasses.ts, 24, 3)) +>A.A : Symbol(A.A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 10)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 0)) +>A : Symbol(A.A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 10)) + +var AG = new A.AG() +>AG : Symbol(AG, Decl(ModuleWithExportedAndNonExportedClasses.ts, 26, 3)) +>A.AG : Symbol(A.AG, Decl(ModuleWithExportedAndNonExportedClasses.ts, 4, 5)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 0)) +>AG : Symbol(A.AG, Decl(ModuleWithExportedAndNonExportedClasses.ts, 4, 5)) + +// errors expected, these are not exported +var a2 = new A.A2(); +>a2 : Symbol(a2, Decl(ModuleWithExportedAndNonExportedClasses.ts, 29, 3)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 0)) + +var ag2 = new A.A2(); +>ag2 : Symbol(ag2, Decl(ModuleWithExportedAndNonExportedClasses.ts, 30, 3)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedClasses.ts, 0, 0)) + + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.types b/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.types new file mode 100644 index 00000000000..233d03cca02 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedClasses.types @@ -0,0 +1,89 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedClasses.ts === +module A { +>A : typeof A + + export class A { +>A : A + + id: number; +>id : number + + name: string; +>name : string + } + + export class AG{ +>AG : AG +>T : T +>U : U + + id: T; +>id : T +>T : T + + name: U; +>name : U +>U : U + } + + class A2 { +>A2 : A2 + + id: number; +>id : number + + name: string; +>name : string + } + + class AG2{ +>AG2 : AG2 +>T : T +>U : U + + id: T; +>id : T +>T : T + + name: U; +>name : U +>U : U + } +} + +// no errors expected, these are all exported +var a: { id: number; name: string }; +>a : { id: number; name: string; } +>id : number +>name : string + +var a = new A.A(); +>a : { id: number; name: string; } +>new A.A() : A.A +>A.A : typeof A.A +>A : typeof A +>A : typeof A.A + +var AG = new A.AG() +>AG : A.AG +>new A.AG() : A.AG +>A.AG : typeof A.AG +>A : typeof A +>AG : typeof A.AG + +// errors expected, these are not exported +var a2 = new A.A2(); +>a2 : any +>new A.A2() : any +>A.A2 : any +>A : typeof A +>A2 : any + +var ag2 = new A.A2(); +>ag2 : any +>new A.A2() : any +>A.A2 : any +>A : typeof A +>A2 : any + + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.symbols b/tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.symbols new file mode 100644 index 00000000000..38b93290f75 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.symbols @@ -0,0 +1,31 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedEnums.ts === +module A { +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 0)) + + export enum Color { Red, Blue } +>Color : Symbol(Color, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 10)) +>Red : Symbol(Color.Red, Decl(ModuleWithExportedAndNonExportedEnums.ts, 1, 23)) +>Blue : Symbol(Color.Blue, Decl(ModuleWithExportedAndNonExportedEnums.ts, 1, 28)) + + enum Day { Monday, Tuesday } +>Day : Symbol(Day, Decl(ModuleWithExportedAndNonExportedEnums.ts, 1, 35)) +>Monday : Symbol(Day.Monday, Decl(ModuleWithExportedAndNonExportedEnums.ts, 2, 14)) +>Tuesday : Symbol(Day.Tuesday, Decl(ModuleWithExportedAndNonExportedEnums.ts, 2, 22)) +} + +// not an error since exported +var a: A.Color = A.Color.Red; +>a : Symbol(a, Decl(ModuleWithExportedAndNonExportedEnums.ts, 6, 3)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 0)) +>Color : Symbol(A.Color, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 10)) +>A.Color.Red : Symbol(A.Color.Red, Decl(ModuleWithExportedAndNonExportedEnums.ts, 1, 23)) +>A.Color : Symbol(A.Color, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 10)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 0)) +>Color : Symbol(A.Color, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 10)) +>Red : Symbol(A.Color.Red, Decl(ModuleWithExportedAndNonExportedEnums.ts, 1, 23)) + +// error not exported +var b = A.Day.Monday; +>b : Symbol(b, Decl(ModuleWithExportedAndNonExportedEnums.ts, 9, 3)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedEnums.ts, 0, 0)) + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.types b/tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.types new file mode 100644 index 00000000000..54222846995 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedEnums.types @@ -0,0 +1,35 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedEnums.ts === +module A { +>A : typeof A + + export enum Color { Red, Blue } +>Color : Color +>Red : Color.Red +>Blue : Color.Blue + + enum Day { Monday, Tuesday } +>Day : Day +>Monday : Day.Monday +>Tuesday : Day.Tuesday +} + +// not an error since exported +var a: A.Color = A.Color.Red; +>a : A.Color +>A : any +>Color : A.Color +>A.Color.Red : A.Color.Red +>A.Color : typeof A.Color +>A : typeof A +>Color : typeof A.Color +>Red : A.Color.Red + +// error not exported +var b = A.Day.Monday; +>b : any +>A.Day.Monday : any +>A.Day : any +>A : typeof A +>Day : any +>Monday : any + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.symbols b/tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.symbols new file mode 100644 index 00000000000..83104e9af73 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.symbols @@ -0,0 +1,75 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedFunctions.ts === +module A { +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 0)) + + export function fn(s: string) { +>fn : Symbol(fn, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 10)) +>s : Symbol(s, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 2, 23)) + + return true; + } + + export function fng(s: T): U { +>fng : Symbol(fng, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 4, 5)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 6, 24)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 6, 26)) +>s : Symbol(s, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 6, 30)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 6, 24)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 6, 26)) + + return null; + } + + function fn2(s: string) { +>fn2 : Symbol(fn2, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 8, 5)) +>s : Symbol(s, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 10, 17)) + + return false; + } + + function fng2(s: T): U { +>fng2 : Symbol(fng2, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 12, 5)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 14, 18)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 14, 20)) +>s : Symbol(s, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 14, 24)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 14, 18)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 14, 20)) + + return null; + } +} + +// these should not be errors since the functions are exported +var fn: (s: string) => boolean; +>fn : Symbol(fn, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 20, 3), Decl(ModuleWithExportedAndNonExportedFunctions.ts, 21, 3)) +>s : Symbol(s, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 20, 9)) + +var fn = A.fn; +>fn : Symbol(fn, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 20, 3), Decl(ModuleWithExportedAndNonExportedFunctions.ts, 21, 3)) +>A.fn : Symbol(A.fn, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 10)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 0)) +>fn : Symbol(A.fn, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 10)) + +var fng: (s: T) => U; +>fng : Symbol(fng, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 23, 3), Decl(ModuleWithExportedAndNonExportedFunctions.ts, 24, 3)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 23, 10)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 23, 12)) +>s : Symbol(s, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 23, 16)) +>T : Symbol(T, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 23, 10)) +>U : Symbol(U, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 23, 12)) + +var fng = A.fng; // bug 838015 +>fng : Symbol(fng, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 23, 3), Decl(ModuleWithExportedAndNonExportedFunctions.ts, 24, 3)) +>A.fng : Symbol(A.fng, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 4, 5)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 0)) +>fng : Symbol(A.fng, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 4, 5)) + +// these should be errors since the functions are not exported +var fn2 = A.fn2; +>fn2 : Symbol(fn2, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 27, 3)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 0)) + +var fng2 = A.fng2; +>fng2 : Symbol(fng2, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 28, 3)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedFunctions.ts, 0, 0)) + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.types b/tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.types new file mode 100644 index 00000000000..123ee413d76 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.types @@ -0,0 +1,83 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedFunctions.ts === +module A { +>A : typeof A + + export function fn(s: string) { +>fn : (s: string) => boolean +>s : string + + return true; +>true : true + } + + export function fng(s: T): U { +>fng : (s: T) => U +>T : T +>U : U +>s : T +>T : T +>U : U + + return null; +>null : null + } + + function fn2(s: string) { +>fn2 : (s: string) => boolean +>s : string + + return false; +>false : false + } + + function fng2(s: T): U { +>fng2 : (s: T) => U +>T : T +>U : U +>s : T +>T : T +>U : U + + return null; +>null : null + } +} + +// these should not be errors since the functions are exported +var fn: (s: string) => boolean; +>fn : (s: string) => boolean +>s : string + +var fn = A.fn; +>fn : (s: string) => boolean +>A.fn : (s: string) => boolean +>A : typeof A +>fn : (s: string) => boolean + +var fng: (s: T) => U; +>fng : (s: T) => U +>T : T +>U : U +>s : T +>T : T +>U : U + +var fng = A.fng; // bug 838015 +>fng : (s: T) => U +>A.fng : (s: T) => U +>A : typeof A +>fng : (s: T) => U + +// these should be errors since the functions are not exported +var fn2 = A.fn2; +>fn2 : any +>A.fn2 : any +>A : typeof A +>fn2 : any + +var fng2 = A.fng2; +>fng2 : any +>A.fng2 : any +>A : typeof A +>fng2 : any + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.symbols b/tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.symbols new file mode 100644 index 00000000000..bf2bbb39607 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.symbols @@ -0,0 +1,109 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedImportAlias.ts === +module A { +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 0)) + + export interface Point { +>Point : Symbol(Point, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 10)) + + x: number; +>x : Symbol(Point.x, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 1, 28)) + + y: number; +>y : Symbol(Point.y, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 2, 18)) + } + + interface Point3d extends Point { +>Point3d : Symbol(Point3d, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 4, 5)) +>Point : Symbol(Point, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 10)) + + z: number; +>z : Symbol(Point3d.z, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 6, 37)) + } +} + +module B { +>B : Symbol(B, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 9, 1)) + + export class Line { +>Line : Symbol(Line, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 11, 10)) + + constructor(public start: A.Point, public end: A.Point) { } +>start : Symbol(Line.start, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 13, 20)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 0)) +>Point : Symbol(A.Point, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 10)) +>end : Symbol(Line.end, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 13, 42)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 0)) +>Point : Symbol(A.Point, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 10)) + } +} + +module Geometry { +>Geometry : Symbol(Geometry, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 15, 1)) + + export import Points = A; +>Points : Symbol(Points, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 17, 17)) +>A : Symbol(Points, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 0)) + + import Lines = B; +>Lines : Symbol(Lines, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 18, 29)) +>B : Symbol(Lines, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 9, 1)) + + export var Origin: Points.Point = { x: 0, y: 0 }; +>Origin : Symbol(Origin, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 21, 14)) +>Points : Symbol(Points, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 17, 17)) +>Point : Symbol(Points.Point, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 10)) +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 21, 39)) +>y : Symbol(y, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 21, 45)) + + // this is valid since B.Line _is_ visible outside Geometry + export var Unit: Lines.Line = new Lines.Line(Origin, { x: 1, y: 0 }); +>Unit : Symbol(Unit, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 24, 14)) +>Lines : Symbol(Lines, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 18, 29)) +>Line : Symbol(Lines.Line, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 11, 10)) +>Lines.Line : Symbol(Lines.Line, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 11, 10)) +>Lines : Symbol(Lines, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 18, 29)) +>Line : Symbol(Lines.Line, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 11, 10)) +>Origin : Symbol(Origin, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 21, 14)) +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 24, 58)) +>y : Symbol(y, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 24, 64)) +} + +// expected to work since all are exported +var p: { x: number; y: number }; +>p : Symbol(p, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 28, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 29, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 30, 3)) +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 28, 8)) +>y : Symbol(y, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 28, 19)) + +var p: Geometry.Points.Point; +>p : Symbol(p, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 28, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 29, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 30, 3)) +>Geometry : Symbol(Geometry, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 15, 1)) +>Points : Symbol(Geometry.Points, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 17, 17)) +>Point : Symbol(A.Point, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 0, 10)) + +var p = Geometry.Origin; +>p : Symbol(p, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 28, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 29, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 30, 3)) +>Geometry.Origin : Symbol(Geometry.Origin, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 21, 14)) +>Geometry : Symbol(Geometry, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 15, 1)) +>Origin : Symbol(Geometry.Origin, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 21, 14)) + +var line: { start: { x: number; y: number }; end: { x: number; y: number; } }; +>line : Symbol(line, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 33, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 36, 3)) +>start : Symbol(start, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 11)) +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 20)) +>y : Symbol(y, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 31)) +>end : Symbol(end, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 44)) +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 51)) +>y : Symbol(y, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 62)) + +var line = Geometry.Unit; +>line : Symbol(line, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 33, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 36, 3)) +>Geometry.Unit : Symbol(Geometry.Unit, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 24, 14)) +>Geometry : Symbol(Geometry, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 15, 1)) +>Unit : Symbol(Geometry.Unit, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 24, 14)) + +// not expected to work since non are exported +var line = Geometry.Lines.Line; +>line : Symbol(line, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 32, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 33, 3), Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 36, 3)) +>Geometry : Symbol(Geometry, Decl(ModuleWithExportedAndNonExportedImportAlias.ts, 15, 1)) + + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.types b/tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.types new file mode 100644 index 00000000000..74e8d7f271f --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.types @@ -0,0 +1,120 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedImportAlias.ts === +module A { +>A : any + + export interface Point { +>Point : Point + + x: number; +>x : number + + y: number; +>y : number + } + + interface Point3d extends Point { +>Point3d : Point3d +>Point : Point + + z: number; +>z : number + } +} + +module B { +>B : typeof B + + export class Line { +>Line : Line + + constructor(public start: A.Point, public end: A.Point) { } +>start : A.Point +>A : any +>Point : A.Point +>end : A.Point +>A : any +>Point : A.Point + } +} + +module Geometry { +>Geometry : typeof Geometry + + export import Points = A; +>Points : any +>A : any + + import Lines = B; +>Lines : typeof Lines +>B : typeof Lines + + export var Origin: Points.Point = { x: 0, y: 0 }; +>Origin : Points.Point +>Points : any +>Point : Points.Point +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + + // this is valid since B.Line _is_ visible outside Geometry + export var Unit: Lines.Line = new Lines.Line(Origin, { x: 1, y: 0 }); +>Unit : Lines.Line +>Lines : any +>Line : Lines.Line +>new Lines.Line(Origin, { x: 1, y: 0 }) : Lines.Line +>Lines.Line : typeof Lines.Line +>Lines : typeof Lines +>Line : typeof Lines.Line +>Origin : Points.Point +>{ x: 1, y: 0 } : { x: number; y: number; } +>x : number +>1 : 1 +>y : number +>0 : 0 +} + +// expected to work since all are exported +var p: { x: number; y: number }; +>p : { x: number; y: number; } +>x : number +>y : number + +var p: Geometry.Points.Point; +>p : { x: number; y: number; } +>Geometry : any +>Points : any +>Point : A.Point + +var p = Geometry.Origin; +>p : { x: number; y: number; } +>Geometry.Origin : A.Point +>Geometry : typeof Geometry +>Origin : A.Point + +var line: { start: { x: number; y: number }; end: { x: number; y: number; } }; +>line : { start: { x: number; y: number; }; end: { x: number; y: number; }; } +>start : { x: number; y: number; } +>x : number +>y : number +>end : { x: number; y: number; } +>x : number +>y : number + +var line = Geometry.Unit; +>line : { start: { x: number; y: number; }; end: { x: number; y: number; }; } +>Geometry.Unit : B.Line +>Geometry : typeof Geometry +>Unit : B.Line + +// not expected to work since non are exported +var line = Geometry.Lines.Line; +>line : { start: { x: number; y: number; }; end: { x: number; y: number; }; } +>Geometry.Lines.Line : any +>Geometry.Lines : any +>Geometry : typeof Geometry +>Lines : any +>Line : any + + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.symbols b/tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.symbols new file mode 100644 index 00000000000..85e84b75476 --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedVariables.ts === +module A { +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedVariables.ts, 0, 0)) + + export var x = 'hello world' +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedVariables.ts, 1, 14)) + + var y = 12; +>y : Symbol(y, Decl(ModuleWithExportedAndNonExportedVariables.ts, 2, 7)) +} + + +var x: string; +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedVariables.ts, 6, 3), Decl(ModuleWithExportedAndNonExportedVariables.ts, 7, 3)) + +var x = A.x; +>x : Symbol(x, Decl(ModuleWithExportedAndNonExportedVariables.ts, 6, 3), Decl(ModuleWithExportedAndNonExportedVariables.ts, 7, 3)) +>A.x : Symbol(A.x, Decl(ModuleWithExportedAndNonExportedVariables.ts, 1, 14)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedVariables.ts, 0, 0)) +>x : Symbol(A.x, Decl(ModuleWithExportedAndNonExportedVariables.ts, 1, 14)) + +// Error, since y is not exported +var y = A.y; +>y : Symbol(y, Decl(ModuleWithExportedAndNonExportedVariables.ts, 10, 3)) +>A : Symbol(A, Decl(ModuleWithExportedAndNonExportedVariables.ts, 0, 0)) + diff --git a/tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.types b/tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.types new file mode 100644 index 00000000000..67c754765cc --- /dev/null +++ b/tests/baselines/reference/ModuleWithExportedAndNonExportedVariables.types @@ -0,0 +1,30 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/ModuleWithExportedAndNonExportedVariables.ts === +module A { +>A : typeof A + + export var x = 'hello world' +>x : string +>'hello world' : "hello world" + + var y = 12; +>y : number +>12 : 12 +} + + +var x: string; +>x : string + +var x = A.x; +>x : string +>A.x : string +>A : typeof A +>x : string + +// Error, since y is not exported +var y = A.y; +>y : any +>A.y : any +>A : typeof A +>y : any + diff --git a/tests/baselines/reference/NonInitializedExportInInternalModule.symbols b/tests/baselines/reference/NonInitializedExportInInternalModule.symbols new file mode 100644 index 00000000000..afa9504856e --- /dev/null +++ b/tests/baselines/reference/NonInitializedExportInInternalModule.symbols @@ -0,0 +1,93 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts === +module Inner { +>Inner : Symbol(Inner, Decl(NonInitializedExportInInternalModule.ts, 0, 0)) + + var; + let; + const; + + export var a; +>a : Symbol(a, Decl(NonInitializedExportInInternalModule.ts, 5, 14)) + + export let b; +>b : Symbol(b, Decl(NonInitializedExportInInternalModule.ts, 6, 14)) + + export var c: string; +>c : Symbol(c, Decl(NonInitializedExportInInternalModule.ts, 7, 14)) + + export let d: number; +>d : Symbol(d, Decl(NonInitializedExportInInternalModule.ts, 8, 14)) + + class A {} +>A : Symbol(A, Decl(NonInitializedExportInInternalModule.ts, 8, 25)) + + export var e: A; +>e : Symbol(e, Decl(NonInitializedExportInInternalModule.ts, 10, 14)) +>A : Symbol(A, Decl(NonInitializedExportInInternalModule.ts, 8, 25)) + + export let f: A; +>f : Symbol(f, Decl(NonInitializedExportInInternalModule.ts, 11, 14)) +>A : Symbol(A, Decl(NonInitializedExportInInternalModule.ts, 8, 25)) + + namespace B { +>B : Symbol(B, Decl(NonInitializedExportInInternalModule.ts, 11, 20)) + + export let a = 1, b, c = 2; +>a : Symbol(a, Decl(NonInitializedExportInInternalModule.ts, 14, 18)) +>b : Symbol(b, Decl(NonInitializedExportInInternalModule.ts, 14, 25)) +>c : Symbol(c, Decl(NonInitializedExportInInternalModule.ts, 14, 28)) + + export let x, y, z; +>x : Symbol(x, Decl(NonInitializedExportInInternalModule.ts, 15, 18)) +>y : Symbol(y, Decl(NonInitializedExportInInternalModule.ts, 15, 21)) +>z : Symbol(z, Decl(NonInitializedExportInInternalModule.ts, 15, 24)) + } + + module C { +>C : Symbol(C, Decl(NonInitializedExportInInternalModule.ts, 16, 5)) + + export var a = 1, b, c = 2; +>a : Symbol(a, Decl(NonInitializedExportInInternalModule.ts, 19, 18)) +>b : Symbol(b, Decl(NonInitializedExportInInternalModule.ts, 19, 25)) +>c : Symbol(c, Decl(NonInitializedExportInInternalModule.ts, 19, 28)) + + export var x, y, z; +>x : Symbol(x, Decl(NonInitializedExportInInternalModule.ts, 20, 18)) +>y : Symbol(y, Decl(NonInitializedExportInInternalModule.ts, 20, 21)) +>z : Symbol(z, Decl(NonInitializedExportInInternalModule.ts, 20, 24)) + } + + // Shouldn't be filtered + export var a1 = 1; +>a1 : Symbol(a1, Decl(NonInitializedExportInInternalModule.ts, 24, 14)) + + export let b1 = 1; +>b1 : Symbol(b1, Decl(NonInitializedExportInInternalModule.ts, 25, 14)) + + export var c1: string = 'a'; +>c1 : Symbol(c1, Decl(NonInitializedExportInInternalModule.ts, 26, 14)) + + export let d1: number = 1; +>d1 : Symbol(d1, Decl(NonInitializedExportInInternalModule.ts, 27, 14)) + + class D {} +>D : Symbol(D, Decl(NonInitializedExportInInternalModule.ts, 27, 30)) + + export var e1 = new D; +>e1 : Symbol(e1, Decl(NonInitializedExportInInternalModule.ts, 29, 14)) +>D : Symbol(D, Decl(NonInitializedExportInInternalModule.ts, 27, 30)) + + export let f1 = new D; +>f1 : Symbol(f1, Decl(NonInitializedExportInInternalModule.ts, 30, 14)) +>D : Symbol(D, Decl(NonInitializedExportInInternalModule.ts, 27, 30)) + + export var g1: D = new D; +>g1 : Symbol(g1, Decl(NonInitializedExportInInternalModule.ts, 31, 14)) +>D : Symbol(D, Decl(NonInitializedExportInInternalModule.ts, 27, 30)) +>D : Symbol(D, Decl(NonInitializedExportInInternalModule.ts, 27, 30)) + + export let h1: D = new D; +>h1 : Symbol(h1, Decl(NonInitializedExportInInternalModule.ts, 32, 14)) +>D : Symbol(D, Decl(NonInitializedExportInInternalModule.ts, 27, 30)) +>D : Symbol(D, Decl(NonInitializedExportInInternalModule.ts, 27, 30)) +} diff --git a/tests/baselines/reference/NonInitializedExportInInternalModule.types b/tests/baselines/reference/NonInitializedExportInInternalModule.types new file mode 100644 index 00000000000..4c8581c3283 --- /dev/null +++ b/tests/baselines/reference/NonInitializedExportInInternalModule.types @@ -0,0 +1,107 @@ +=== tests/cases/conformance/internalModules/exportDeclarations/NonInitializedExportInInternalModule.ts === +module Inner { +>Inner : typeof Inner + + var; + let; +>let : any + + const; + + export var a; +>a : any + + export let b; +>b : any + + export var c: string; +>c : string + + export let d: number; +>d : number + + class A {} +>A : A + + export var e: A; +>e : A +>A : A + + export let f: A; +>f : A +>A : A + + namespace B { +>B : typeof B + + export let a = 1, b, c = 2; +>a : number +>1 : 1 +>b : any +>c : number +>2 : 2 + + export let x, y, z; +>x : any +>y : any +>z : any + } + + module C { +>C : typeof C + + export var a = 1, b, c = 2; +>a : number +>1 : 1 +>b : any +>c : number +>2 : 2 + + export var x, y, z; +>x : any +>y : any +>z : any + } + + // Shouldn't be filtered + export var a1 = 1; +>a1 : number +>1 : 1 + + export let b1 = 1; +>b1 : number +>1 : 1 + + export var c1: string = 'a'; +>c1 : string +>'a' : "a" + + export let d1: number = 1; +>d1 : number +>1 : 1 + + class D {} +>D : D + + export var e1 = new D; +>e1 : D +>new D : D +>D : typeof D + + export let f1 = new D; +>f1 : D +>new D : D +>D : typeof D + + export var g1: D = new D; +>g1 : D +>D : D +>new D : D +>D : typeof D + + export let h1: D = new D; +>h1 : D +>D : D +>new D : D +>D : typeof D +} diff --git a/tests/baselines/reference/ParameterList13.symbols b/tests/baselines/reference/ParameterList13.symbols new file mode 100644 index 00000000000..7ed8ca187de --- /dev/null +++ b/tests/baselines/reference/ParameterList13.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ParameterList13.ts === +interface I { +>I : Symbol(I, Decl(ParameterList13.ts, 0, 0)) + + new (public x); +>x : Symbol(x, Decl(ParameterList13.ts, 1, 9)) +} diff --git a/tests/baselines/reference/ParameterList13.types b/tests/baselines/reference/ParameterList13.types new file mode 100644 index 00000000000..22819406560 --- /dev/null +++ b/tests/baselines/reference/ParameterList13.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ParameterList13.ts === +interface I { +>I : I + + new (public x); +>x : any +} diff --git a/tests/baselines/reference/ParameterList4.symbols b/tests/baselines/reference/ParameterList4.symbols new file mode 100644 index 00000000000..262710a77d0 --- /dev/null +++ b/tests/baselines/reference/ParameterList4.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/ParameterList4.ts === +function F(public A) { +>F : Symbol(F, Decl(ParameterList4.ts, 0, 0)) +>A : Symbol(A, Decl(ParameterList4.ts, 0, 11)) +} diff --git a/tests/baselines/reference/ParameterList4.types b/tests/baselines/reference/ParameterList4.types new file mode 100644 index 00000000000..5d947f15c4b --- /dev/null +++ b/tests/baselines/reference/ParameterList4.types @@ -0,0 +1,5 @@ +=== tests/cases/compiler/ParameterList4.ts === +function F(public A) { +>F : (public A: any) => void +>A : any +} diff --git a/tests/baselines/reference/ParameterList5.symbols b/tests/baselines/reference/ParameterList5.symbols new file mode 100644 index 00000000000..87b3181249b --- /dev/null +++ b/tests/baselines/reference/ParameterList5.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/ParameterList5.ts === +function A(): (public B) => C { +>A : Symbol(A, Decl(ParameterList5.ts, 0, 0)) +>B : Symbol(B, Decl(ParameterList5.ts, 0, 15)) +} diff --git a/tests/baselines/reference/ParameterList5.types b/tests/baselines/reference/ParameterList5.types new file mode 100644 index 00000000000..3c07e99bb48 --- /dev/null +++ b/tests/baselines/reference/ParameterList5.types @@ -0,0 +1,6 @@ +=== tests/cases/compiler/ParameterList5.ts === +function A(): (public B) => C { +>A : () => (public B: any) => any +>B : any +>C : No type information available! +} diff --git a/tests/baselines/reference/ParameterList6.symbols b/tests/baselines/reference/ParameterList6.symbols new file mode 100644 index 00000000000..b7baba3f462 --- /dev/null +++ b/tests/baselines/reference/ParameterList6.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/ParameterList6.ts === +class C { +>C : Symbol(C, Decl(ParameterList6.ts, 0, 0)) + + constructor(C: (public A) => any) { +>C : Symbol(C, Decl(ParameterList6.ts, 1, 14)) +>A : Symbol(A, Decl(ParameterList6.ts, 1, 18)) + } +} diff --git a/tests/baselines/reference/ParameterList6.types b/tests/baselines/reference/ParameterList6.types new file mode 100644 index 00000000000..26947a4a23f --- /dev/null +++ b/tests/baselines/reference/ParameterList6.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/ParameterList6.ts === +class C { +>C : C + + constructor(C: (public A) => any) { +>C : (public A: any) => any +>A : any + } +} diff --git a/tests/baselines/reference/ParameterList7.symbols b/tests/baselines/reference/ParameterList7.symbols new file mode 100644 index 00000000000..8d01805e475 --- /dev/null +++ b/tests/baselines/reference/ParameterList7.symbols @@ -0,0 +1,13 @@ +=== tests/cases/compiler/ParameterList7.ts === +class C1 { +>C1 : Symbol(C1, Decl(ParameterList7.ts, 0, 0)) + + constructor(public p1:string); // ERROR +>p1 : Symbol(C1.p1, Decl(ParameterList7.ts, 1, 13)) + + constructor(private p2:number); // ERROR +>p2 : Symbol(C1.p2, Decl(ParameterList7.ts, 2, 13)) + + constructor(public p3:any) {} // OK +>p3 : Symbol(C1.p3, Decl(ParameterList7.ts, 3, 13)) +} diff --git a/tests/baselines/reference/ParameterList7.types b/tests/baselines/reference/ParameterList7.types new file mode 100644 index 00000000000..6503c09e5a5 --- /dev/null +++ b/tests/baselines/reference/ParameterList7.types @@ -0,0 +1,13 @@ +=== tests/cases/compiler/ParameterList7.ts === +class C1 { +>C1 : C1 + + constructor(public p1:string); // ERROR +>p1 : string + + constructor(private p2:number); // ERROR +>p2 : number + + constructor(public p3:any) {} // OK +>p3 : any +} diff --git a/tests/baselines/reference/ParameterList8.symbols b/tests/baselines/reference/ParameterList8.symbols new file mode 100644 index 00000000000..919de165ea9 --- /dev/null +++ b/tests/baselines/reference/ParameterList8.symbols @@ -0,0 +1,13 @@ +=== tests/cases/compiler/ParameterList8.ts === +declare class C2 { +>C2 : Symbol(C2, Decl(ParameterList8.ts, 0, 0)) + + constructor(public p1:string); // ERROR +>p1 : Symbol(C2.p1, Decl(ParameterList8.ts, 1, 13)) + + constructor(private p2:number); // ERROR +>p2 : Symbol(C2.p2, Decl(ParameterList8.ts, 2, 13)) + + constructor(public p3:any); // ERROR +>p3 : Symbol(C2.p3, Decl(ParameterList8.ts, 3, 13)) +} diff --git a/tests/baselines/reference/ParameterList8.types b/tests/baselines/reference/ParameterList8.types new file mode 100644 index 00000000000..150ebb7b7d4 --- /dev/null +++ b/tests/baselines/reference/ParameterList8.types @@ -0,0 +1,13 @@ +=== tests/cases/compiler/ParameterList8.ts === +declare class C2 { +>C2 : C2 + + constructor(public p1:string); // ERROR +>p1 : string + + constructor(private p2:number); // ERROR +>p2 : number + + constructor(public p3:any); // ERROR +>p3 : any +} diff --git a/tests/baselines/reference/Protected1.symbols b/tests/baselines/reference/Protected1.symbols new file mode 100644 index 00000000000..1fbefb2a8af --- /dev/null +++ b/tests/baselines/reference/Protected1.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected1.ts === +protected class C { +>C : Symbol(C, Decl(Protected1.ts, 0, 0)) +} diff --git a/tests/baselines/reference/Protected1.types b/tests/baselines/reference/Protected1.types new file mode 100644 index 00000000000..3d648e6a4b4 --- /dev/null +++ b/tests/baselines/reference/Protected1.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected1.ts === +protected class C { +>C : C +} diff --git a/tests/baselines/reference/Protected2.symbols b/tests/baselines/reference/Protected2.symbols new file mode 100644 index 00000000000..c1d9deec2c1 --- /dev/null +++ b/tests/baselines/reference/Protected2.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected2.ts === +protected module M { +>M : Symbol(M, Decl(Protected2.ts, 0, 0)) +} diff --git a/tests/baselines/reference/Protected2.types b/tests/baselines/reference/Protected2.types new file mode 100644 index 00000000000..d4a18b3f2fc --- /dev/null +++ b/tests/baselines/reference/Protected2.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected2.ts === +protected module M { +>M : any +} diff --git a/tests/baselines/reference/Protected4.symbols b/tests/baselines/reference/Protected4.symbols new file mode 100644 index 00000000000..54814def624 --- /dev/null +++ b/tests/baselines/reference/Protected4.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected4.ts === +class C { +>C : Symbol(C, Decl(Protected4.ts, 0, 0)) + + protected public m() { } +>m : Symbol(C.m, Decl(Protected4.ts, 0, 9)) +} diff --git a/tests/baselines/reference/Protected4.types b/tests/baselines/reference/Protected4.types new file mode 100644 index 00000000000..af4d56083c5 --- /dev/null +++ b/tests/baselines/reference/Protected4.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected4.ts === +class C { +>C : C + + protected public m() { } +>m : () => void +} diff --git a/tests/baselines/reference/Protected6.symbols b/tests/baselines/reference/Protected6.symbols new file mode 100644 index 00000000000..321c9fbe887 --- /dev/null +++ b/tests/baselines/reference/Protected6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected6.ts === +class C { +>C : Symbol(C, Decl(Protected6.ts, 0, 0)) + + static protected m() { } +>m : Symbol(C.m, Decl(Protected6.ts, 0, 9)) +} diff --git a/tests/baselines/reference/Protected6.types b/tests/baselines/reference/Protected6.types new file mode 100644 index 00000000000..4a902fe5460 --- /dev/null +++ b/tests/baselines/reference/Protected6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected6.ts === +class C { +>C : C + + static protected m() { } +>m : () => void +} diff --git a/tests/baselines/reference/Protected7.symbols b/tests/baselines/reference/Protected7.symbols new file mode 100644 index 00000000000..e72be44f210 --- /dev/null +++ b/tests/baselines/reference/Protected7.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected7.ts === +class C { +>C : Symbol(C, Decl(Protected7.ts, 0, 0)) + + protected private m() { } +>m : Symbol(C.m, Decl(Protected7.ts, 0, 9)) +} diff --git a/tests/baselines/reference/Protected7.types b/tests/baselines/reference/Protected7.types new file mode 100644 index 00000000000..d3b770676ce --- /dev/null +++ b/tests/baselines/reference/Protected7.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/parser/ecmascript5/Protected/Protected7.ts === +class C { +>C : C + + protected private m() { } +>m : () => void +} diff --git a/tests/baselines/reference/TemplateExpression1.symbols b/tests/baselines/reference/TemplateExpression1.symbols new file mode 100644 index 00000000000..d272dae79d2 --- /dev/null +++ b/tests/baselines/reference/TemplateExpression1.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/templates/TemplateExpression1.ts === +var v = `foo ${ a +>v : Symbol(v, Decl(TemplateExpression1.ts, 0, 3)) + diff --git a/tests/baselines/reference/TemplateExpression1.types b/tests/baselines/reference/TemplateExpression1.types new file mode 100644 index 00000000000..e23083d83ec --- /dev/null +++ b/tests/baselines/reference/TemplateExpression1.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/templates/TemplateExpression1.ts === +var v = `foo ${ a +>v : string +>`foo ${ a : string +>a : any + diff --git a/tests/baselines/reference/TupleType3.symbols b/tests/baselines/reference/TupleType3.symbols new file mode 100644 index 00000000000..a2466e85121 --- /dev/null +++ b/tests/baselines/reference/TupleType3.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType3.ts === +var v: [] +>v : Symbol(v, Decl(TupleType3.ts, 0, 3)) + diff --git a/tests/baselines/reference/TupleType3.types b/tests/baselines/reference/TupleType3.types new file mode 100644 index 00000000000..5944aabd7d4 --- /dev/null +++ b/tests/baselines/reference/TupleType3.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType3.ts === +var v: [] +>v : [] + diff --git a/tests/baselines/reference/TupleType4.symbols b/tests/baselines/reference/TupleType4.symbols new file mode 100644 index 00000000000..9b5e4a1c00c --- /dev/null +++ b/tests/baselines/reference/TupleType4.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType4.ts === +var v: [ +>v : Symbol(v, Decl(TupleType4.ts, 0, 3)) + diff --git a/tests/baselines/reference/TupleType4.types b/tests/baselines/reference/TupleType4.types new file mode 100644 index 00000000000..7ad64f5606b --- /dev/null +++ b/tests/baselines/reference/TupleType4.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType4.ts === +var v: [ +>v : [] + diff --git a/tests/baselines/reference/TupleType5.symbols b/tests/baselines/reference/TupleType5.symbols new file mode 100644 index 00000000000..6c20b3f7a66 --- /dev/null +++ b/tests/baselines/reference/TupleType5.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType5.ts === +var v: [number,] +>v : Symbol(v, Decl(TupleType5.ts, 0, 3)) + diff --git a/tests/baselines/reference/TupleType5.types b/tests/baselines/reference/TupleType5.types new file mode 100644 index 00000000000..6c23baf57d9 --- /dev/null +++ b/tests/baselines/reference/TupleType5.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType5.ts === +var v: [number,] +>v : [number] + diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.symbols b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.symbols new file mode 100644 index 00000000000..95ce9c7e429 --- /dev/null +++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.symbols @@ -0,0 +1,63 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts === +module A { +>A : Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 5, 1)) + + export class Point { +>Point : Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 0, 10)) + + x: number; +>x : Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 1, 24)) + + y: number; +>y : Symbol(Point.y, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 2, 18)) + } +} + +module A{ +>A : Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 5, 1)) + + // expected error + export class Point { +>Point : Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 7, 9)) + + origin: number; +>origin : Symbol(A.Point.origin, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 9, 24)) + + angle: number; +>angle : Symbol(A.Point.angle, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 10, 23)) + } +} + +module X.Y.Z { +>X : Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 13, 1), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 19, 1)) +>Y : Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 15, 9), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 21, 10)) +>Z : Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 15, 11), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 22, 21)) + + export class Line { +>Line : Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 15, 14)) + + length: number; +>length : Symbol(Line.length, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 16, 23)) + } +} + +module X { +>X : Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 13, 1), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 19, 1)) + + export module Y { +>Y : Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 15, 9), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 21, 10)) + + export module Z { +>Z : Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 15, 11), Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 22, 21)) + + // expected error + export class Line { +>Line : Symbol(Z.Line, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 23, 25)) + + name: string; +>name : Symbol(Z.Line.name, Decl(TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts, 25, 31)) + } + } + } +} + diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.types b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.types new file mode 100644 index 00000000000..bc4b6c847c5 --- /dev/null +++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.types @@ -0,0 +1,63 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedClassesOfTheSameName.ts === +module A { +>A : typeof A + + export class Point { +>Point : Point + + x: number; +>x : number + + y: number; +>y : number + } +} + +module A{ +>A : typeof A + + // expected error + export class Point { +>Point : A.Point + + origin: number; +>origin : number + + angle: number; +>angle : number + } +} + +module X.Y.Z { +>X : typeof X +>Y : typeof Y +>Z : typeof Z + + export class Line { +>Line : Line + + length: number; +>length : number + } +} + +module X { +>X : typeof X + + export module Y { +>Y : typeof Y + + export module Z { +>Z : typeof Z + + // expected error + export class Line { +>Line : Z.Line + + name: string; +>name : string + } + } + } +} + diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.symbols b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.symbols new file mode 100644 index 00000000000..a9d0459064a --- /dev/null +++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.symbols @@ -0,0 +1,66 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts === +export module A { +>A : Symbol(A, Decl(part1.ts, 0, 0)) + + export interface Point { +>Point : Symbol(Point, Decl(part1.ts, 0, 17)) + + x: number; +>x : Symbol(Point.x, Decl(part1.ts, 1, 28)) + + y: number; +>y : Symbol(Point.y, Decl(part1.ts, 2, 18)) + } + + export module Utils { +>Utils : Symbol(Utils, Decl(part1.ts, 4, 5)) + + export function mirror(p: T) { +>mirror : Symbol(mirror, Decl(part1.ts, 6, 25)) +>T : Symbol(T, Decl(part1.ts, 7, 31)) +>Point : Symbol(Point, Decl(part1.ts, 0, 17)) +>p : Symbol(p, Decl(part1.ts, 7, 48)) +>T : Symbol(T, Decl(part1.ts, 7, 31)) + + return { x: p.y, y: p.x }; +>x : Symbol(x, Decl(part1.ts, 8, 20)) +>p.y : Symbol(Point.y, Decl(part1.ts, 2, 18)) +>p : Symbol(p, Decl(part1.ts, 7, 48)) +>y : Symbol(Point.y, Decl(part1.ts, 2, 18)) +>y : Symbol(y, Decl(part1.ts, 8, 28)) +>p.x : Symbol(Point.x, Decl(part1.ts, 1, 28)) +>p : Symbol(p, Decl(part1.ts, 7, 48)) +>x : Symbol(Point.x, Decl(part1.ts, 1, 28)) + } + } + + export var Origin: Point = { x: 0, y: 0 }; +>Origin : Symbol(Origin, Decl(part1.ts, 12, 14)) +>Point : Symbol(Point, Decl(part1.ts, 0, 17)) +>x : Symbol(x, Decl(part1.ts, 12, 32)) +>y : Symbol(y, Decl(part1.ts, 12, 38)) +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts === +export module A { +>A : Symbol(A, Decl(part2.ts, 0, 0)) + + // collision with 'Origin' var in other part of merged module + export var Origin: Point = { x: 0, y: 0 }; +>Origin : Symbol(Origin, Decl(part2.ts, 2, 14)) +>x : Symbol(x, Decl(part2.ts, 2, 32)) +>y : Symbol(y, Decl(part2.ts, 2, 38)) + + export module Utils { +>Utils : Symbol(Utils, Decl(part2.ts, 2, 46)) + + export class Plane { +>Plane : Symbol(Plane, Decl(part2.ts, 4, 25)) + + constructor(public tl: Point, public br: Point) { } +>tl : Symbol(Plane.tl, Decl(part2.ts, 6, 24)) +>br : Symbol(Plane.br, Decl(part2.ts, 6, 41)) + } + } +} + diff --git a/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types new file mode 100644 index 00000000000..b9132a1d2cb --- /dev/null +++ b/tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types @@ -0,0 +1,76 @@ +=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts === +export module A { +>A : typeof A + + export interface Point { +>Point : Point + + x: number; +>x : number + + y: number; +>y : number + } + + export module Utils { +>Utils : typeof Utils + + export function mirror(p: T) { +>mirror : (p: T) => { x: number; y: number; } +>T : T +>Point : Point +>p : T +>T : T + + return { x: p.y, y: p.x }; +>{ x: p.y, y: p.x } : { x: number; y: number; } +>x : number +>p.y : number +>p : T +>y : number +>y : number +>p.x : number +>p : T +>x : number + } + } + + export var Origin: Point = { x: 0, y: 0 }; +>Origin : Point +>Point : Point +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 +} + +=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts === +export module A { +>A : typeof A + + // collision with 'Origin' var in other part of merged module + export var Origin: Point = { x: 0, y: 0 }; +>Origin : any +>Point : No type information available! +>{ x: 0, y: 0 } : { x: number; y: number; } +>x : number +>0 : 0 +>y : number +>0 : 0 + + export module Utils { +>Utils : typeof Utils + + export class Plane { +>Plane : Plane + + constructor(public tl: Point, public br: Point) { } +>tl : any +>Point : No type information available! +>br : any +>Point : No type information available! + } + } +} + diff --git a/tests/baselines/reference/TypeArgumentList1.symbols b/tests/baselines/reference/TypeArgumentList1.symbols new file mode 100644 index 00000000000..d2803e79101 --- /dev/null +++ b/tests/baselines/reference/TypeArgumentList1.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/TypeArgumentLists/TypeArgumentList1.ts === +Foo(4, 5, 6); +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/TypeArgumentList1.types b/tests/baselines/reference/TypeArgumentList1.types new file mode 100644 index 00000000000..5d346592c49 --- /dev/null +++ b/tests/baselines/reference/TypeArgumentList1.types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/TypeArgumentLists/TypeArgumentList1.ts === +Foo(4, 5, 6); +>FooFooFooFoo : any +>A : any +>B : any +> : any +>C>(4, 5, 6) : boolean +>C : any +>(4, 5, 6) : 6 +>4, 5, 6 : 6 +>4, 5 : 5 +>4 : 4 +>5 : 5 +>6 : 6 + diff --git a/tests/baselines/reference/VariableDeclaration11_es6.symbols b/tests/baselines/reference/VariableDeclaration11_es6.symbols new file mode 100644 index 00000000000..feaeb047073 --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration11_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration11_es6.ts === +"use strict"; +No type information for this code.let +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/VariableDeclaration11_es6.types b/tests/baselines/reference/VariableDeclaration11_es6.types new file mode 100644 index 00000000000..8806d07de0c --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration11_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration11_es6.ts === +"use strict"; +>"use strict" : "use strict" + +let +>let : any + diff --git a/tests/baselines/reference/VariableDeclaration13_es6.symbols b/tests/baselines/reference/VariableDeclaration13_es6.symbols new file mode 100644 index 00000000000..7e2d3a370ec --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration13_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts === +// An ExpressionStatement cannot start with the two token sequence `let [` because +// that would make it ambiguous with a `let` LexicalDeclaration whose first LexicalBinding was an ArrayBindingPattern. +var let: any; +>let : Symbol(let, Decl(VariableDeclaration13_es6.ts, 2, 3)) + +let[0] = 100; diff --git a/tests/baselines/reference/VariableDeclaration13_es6.types b/tests/baselines/reference/VariableDeclaration13_es6.types new file mode 100644 index 00000000000..1e40a719c3b --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration13_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration13_es6.ts === +// An ExpressionStatement cannot start with the two token sequence `let [` because +// that would make it ambiguous with a `let` LexicalDeclaration whose first LexicalBinding was an ArrayBindingPattern. +var let: any; +>let : any + +let[0] = 100; +>0 : 0 +>100 : 100 + diff --git a/tests/baselines/reference/VariableDeclaration1_es6.symbols b/tests/baselines/reference/VariableDeclaration1_es6.symbols new file mode 100644 index 00000000000..183f9495caa --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration1_es6.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration1_es6.ts === +const +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/VariableDeclaration1_es6.types b/tests/baselines/reference/VariableDeclaration1_es6.types new file mode 100644 index 00000000000..183f9495caa --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration1_es6.types @@ -0,0 +1,3 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration1_es6.ts === +const +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/VariableDeclaration2_es6.symbols b/tests/baselines/reference/VariableDeclaration2_es6.symbols new file mode 100644 index 00000000000..93d36394e59 --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration2_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration2_es6.ts === +const a +>a : Symbol(a, Decl(VariableDeclaration2_es6.ts, 0, 5)) + diff --git a/tests/baselines/reference/VariableDeclaration2_es6.types b/tests/baselines/reference/VariableDeclaration2_es6.types new file mode 100644 index 00000000000..60f6c46499e --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration2_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration2_es6.ts === +const a +>a : any + diff --git a/tests/baselines/reference/VariableDeclaration4_es6.symbols b/tests/baselines/reference/VariableDeclaration4_es6.symbols new file mode 100644 index 00000000000..e0ed56d9f2c --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration4_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration4_es6.ts === +const a: number +>a : Symbol(a, Decl(VariableDeclaration4_es6.ts, 0, 5)) + diff --git a/tests/baselines/reference/VariableDeclaration4_es6.types b/tests/baselines/reference/VariableDeclaration4_es6.types new file mode 100644 index 00000000000..622d6bb6ba6 --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration4_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration4_es6.ts === +const a: number +>a : number + diff --git a/tests/baselines/reference/VariableDeclaration6_es6.symbols b/tests/baselines/reference/VariableDeclaration6_es6.symbols new file mode 100644 index 00000000000..8d18e77c1a3 --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration6_es6.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration6_es6.ts === +let +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/VariableDeclaration6_es6.types b/tests/baselines/reference/VariableDeclaration6_es6.types new file mode 100644 index 00000000000..a47682673fc --- /dev/null +++ b/tests/baselines/reference/VariableDeclaration6_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration6_es6.ts === +let +>let : any + diff --git a/tests/baselines/reference/YieldExpression10_es6.symbols b/tests/baselines/reference/YieldExpression10_es6.symbols new file mode 100644 index 00000000000..90b6f777338 --- /dev/null +++ b/tests/baselines/reference/YieldExpression10_es6.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts === +var v = { * foo() { +>v : Symbol(v, Decl(YieldExpression10_es6.ts, 0, 3)) +>foo : Symbol(foo, Decl(YieldExpression10_es6.ts, 0, 9)) + + yield(foo); + } +} + diff --git a/tests/baselines/reference/YieldExpression10_es6.types b/tests/baselines/reference/YieldExpression10_es6.types new file mode 100644 index 00000000000..966baa031ed --- /dev/null +++ b/tests/baselines/reference/YieldExpression10_es6.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts === +var v = { * foo() { +>v : { foo(): IterableIterator; } +>{ * foo() { yield(foo); }} : { foo(): IterableIterator; } +>foo : () => IterableIterator + + yield(foo); +>yield(foo) : any +>(foo) : any +>foo : any + } +} + diff --git a/tests/baselines/reference/YieldExpression11_es6.symbols b/tests/baselines/reference/YieldExpression11_es6.symbols new file mode 100644 index 00000000000..fb0302abe66 --- /dev/null +++ b/tests/baselines/reference/YieldExpression11_es6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts === +class C { +>C : Symbol(C, Decl(YieldExpression11_es6.ts, 0, 0)) + + *foo() { +>foo : Symbol(C.foo, Decl(YieldExpression11_es6.ts, 0, 9)) + + yield(foo); + } +} diff --git a/tests/baselines/reference/YieldExpression11_es6.types b/tests/baselines/reference/YieldExpression11_es6.types new file mode 100644 index 00000000000..01257e4f95f --- /dev/null +++ b/tests/baselines/reference/YieldExpression11_es6.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts === +class C { +>C : C + + *foo() { +>foo : () => IterableIterator + + yield(foo); +>yield(foo) : any +>(foo) : any +>foo : any + } +} diff --git a/tests/baselines/reference/YieldExpression12_es6.symbols b/tests/baselines/reference/YieldExpression12_es6.symbols new file mode 100644 index 00000000000..aaa62f47cd1 --- /dev/null +++ b/tests/baselines/reference/YieldExpression12_es6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts === +class C { +>C : Symbol(C, Decl(YieldExpression12_es6.ts, 0, 0)) + + constructor() { + yield foo + } +} diff --git a/tests/baselines/reference/YieldExpression12_es6.types b/tests/baselines/reference/YieldExpression12_es6.types new file mode 100644 index 00000000000..a5743c0c1a7 --- /dev/null +++ b/tests/baselines/reference/YieldExpression12_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression12_es6.ts === +class C { +>C : C + + constructor() { + yield foo +>yield foo : any +>foo : any + } +} diff --git a/tests/baselines/reference/YieldExpression14_es6.symbols b/tests/baselines/reference/YieldExpression14_es6.symbols new file mode 100644 index 00000000000..4ec09c3bef2 --- /dev/null +++ b/tests/baselines/reference/YieldExpression14_es6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts === +class C { +>C : Symbol(C, Decl(YieldExpression14_es6.ts, 0, 0)) + + foo() { +>foo : Symbol(C.foo, Decl(YieldExpression14_es6.ts, 0, 9)) + + yield foo + } +} diff --git a/tests/baselines/reference/YieldExpression14_es6.types b/tests/baselines/reference/YieldExpression14_es6.types new file mode 100644 index 00000000000..3b878347b76 --- /dev/null +++ b/tests/baselines/reference/YieldExpression14_es6.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression14_es6.ts === +class C { +>C : C + + foo() { +>foo : () => void + + yield foo +>yield foo : any +>foo : any + } +} diff --git a/tests/baselines/reference/YieldExpression15_es6.symbols b/tests/baselines/reference/YieldExpression15_es6.symbols new file mode 100644 index 00000000000..0d55bef21ac --- /dev/null +++ b/tests/baselines/reference/YieldExpression15_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts === +var v = () => { +>v : Symbol(v, Decl(YieldExpression15_es6.ts, 0, 3)) + + yield foo + } diff --git a/tests/baselines/reference/YieldExpression15_es6.types b/tests/baselines/reference/YieldExpression15_es6.types new file mode 100644 index 00000000000..33eedb854b0 --- /dev/null +++ b/tests/baselines/reference/YieldExpression15_es6.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression15_es6.ts === +var v = () => { +>v : () => void +>() => { yield foo } : () => void + + yield foo +>yield foo : any +>foo : any + } diff --git a/tests/baselines/reference/YieldExpression16_es6.symbols b/tests/baselines/reference/YieldExpression16_es6.symbols new file mode 100644 index 00000000000..50bedfcb15a --- /dev/null +++ b/tests/baselines/reference/YieldExpression16_es6.symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts === +function* foo() { +>foo : Symbol(foo, Decl(YieldExpression16_es6.ts, 0, 0)) + + function bar() { +>bar : Symbol(bar, Decl(YieldExpression16_es6.ts, 0, 17)) + + yield foo; +>foo : Symbol(foo, Decl(YieldExpression16_es6.ts, 0, 0)) + } +} diff --git a/tests/baselines/reference/YieldExpression16_es6.types b/tests/baselines/reference/YieldExpression16_es6.types new file mode 100644 index 00000000000..661d60a5b58 --- /dev/null +++ b/tests/baselines/reference/YieldExpression16_es6.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts === +function* foo() { +>foo : () => IterableIterator + + function bar() { +>bar : () => void + + yield foo; +>yield foo : any +>foo : () => IterableIterator + } +} diff --git a/tests/baselines/reference/YieldExpression17_es6.symbols b/tests/baselines/reference/YieldExpression17_es6.symbols new file mode 100644 index 00000000000..69a5caa9532 --- /dev/null +++ b/tests/baselines/reference/YieldExpression17_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts === +var v = { get foo() { yield foo; } } +>v : Symbol(v, Decl(YieldExpression17_es6.ts, 0, 3)) +>foo : Symbol(foo, Decl(YieldExpression17_es6.ts, 0, 9)) + diff --git a/tests/baselines/reference/YieldExpression17_es6.types b/tests/baselines/reference/YieldExpression17_es6.types new file mode 100644 index 00000000000..08a8989b9ab --- /dev/null +++ b/tests/baselines/reference/YieldExpression17_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts === +var v = { get foo() { yield foo; } } +>v : { readonly foo: void; } +>{ get foo() { yield foo; } } : { readonly foo: void; } +>foo : void +>yield foo : any +>foo : any + diff --git a/tests/baselines/reference/YieldExpression18_es6.symbols b/tests/baselines/reference/YieldExpression18_es6.symbols new file mode 100644 index 00000000000..34772327eae --- /dev/null +++ b/tests/baselines/reference/YieldExpression18_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts === +"use strict"; +No type information for this code.yield(foo); +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression18_es6.types b/tests/baselines/reference/YieldExpression18_es6.types new file mode 100644 index 00000000000..8322d4721d1 --- /dev/null +++ b/tests/baselines/reference/YieldExpression18_es6.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression18_es6.ts === +"use strict"; +>"use strict" : "use strict" + +yield(foo); +>yield(foo) : any +>yield : any +>foo : any + diff --git a/tests/baselines/reference/YieldExpression1_es6.symbols b/tests/baselines/reference/YieldExpression1_es6.symbols new file mode 100644 index 00000000000..9ca9f6cc899 --- /dev/null +++ b/tests/baselines/reference/YieldExpression1_es6.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression1_es6.ts === +yield; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression1_es6.types b/tests/baselines/reference/YieldExpression1_es6.types new file mode 100644 index 00000000000..bf582b5b7a5 --- /dev/null +++ b/tests/baselines/reference/YieldExpression1_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression1_es6.ts === +yield; +>yield : any + diff --git a/tests/baselines/reference/YieldExpression2_es6.symbols b/tests/baselines/reference/YieldExpression2_es6.symbols new file mode 100644 index 00000000000..99510808bd7 --- /dev/null +++ b/tests/baselines/reference/YieldExpression2_es6.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts === +yield foo; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/YieldExpression2_es6.types b/tests/baselines/reference/YieldExpression2_es6.types new file mode 100644 index 00000000000..abe61e5ea07 --- /dev/null +++ b/tests/baselines/reference/YieldExpression2_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression2_es6.ts === +yield foo; +>yield foo : any +>foo : any + diff --git a/tests/baselines/reference/YieldExpression5_es6.symbols b/tests/baselines/reference/YieldExpression5_es6.symbols new file mode 100644 index 00000000000..61b51d002c0 --- /dev/null +++ b/tests/baselines/reference/YieldExpression5_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression5_es6.ts === +function* foo() { +>foo : Symbol(foo, Decl(YieldExpression5_es6.ts, 0, 0)) + + yield* +} diff --git a/tests/baselines/reference/YieldExpression5_es6.types b/tests/baselines/reference/YieldExpression5_es6.types new file mode 100644 index 00000000000..77a003d0922 --- /dev/null +++ b/tests/baselines/reference/YieldExpression5_es6.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression5_es6.ts === +function* foo() { +>foo : () => IterableIterator + + yield* +>yield* : any +} +> : any + diff --git a/tests/baselines/reference/YieldExpression6_es6.symbols b/tests/baselines/reference/YieldExpression6_es6.symbols new file mode 100644 index 00000000000..67b9059dc0d --- /dev/null +++ b/tests/baselines/reference/YieldExpression6_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts === +function* foo() { +>foo : Symbol(foo, Decl(YieldExpression6_es6.ts, 0, 0)) + + yield*foo +>foo : Symbol(foo, Decl(YieldExpression6_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/YieldExpression6_es6.types b/tests/baselines/reference/YieldExpression6_es6.types new file mode 100644 index 00000000000..c30fc64c8ad --- /dev/null +++ b/tests/baselines/reference/YieldExpression6_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts === +function* foo() { +>foo : () => IterableIterator + + yield*foo +>yield*foo : any +>foo : () => IterableIterator +} diff --git a/tests/baselines/reference/YieldExpression8_es6.symbols b/tests/baselines/reference/YieldExpression8_es6.symbols new file mode 100644 index 00000000000..028ef8dcaa1 --- /dev/null +++ b/tests/baselines/reference/YieldExpression8_es6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts === +yield(foo); +>foo : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11)) + +function* foo() { +>foo : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11)) + + yield(foo); +>foo : Symbol(foo, Decl(YieldExpression8_es6.ts, 0, 11)) +} diff --git a/tests/baselines/reference/YieldExpression8_es6.types b/tests/baselines/reference/YieldExpression8_es6.types new file mode 100644 index 00000000000..67343e3fbfc --- /dev/null +++ b/tests/baselines/reference/YieldExpression8_es6.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts === +yield(foo); +>yield(foo) : any +>yield : any +>foo : () => IterableIterator + +function* foo() { +>foo : () => IterableIterator + + yield(foo); +>yield(foo) : any +>(foo) : () => IterableIterator +>foo : () => IterableIterator +} diff --git a/tests/baselines/reference/YieldExpression9_es6.symbols b/tests/baselines/reference/YieldExpression9_es6.symbols new file mode 100644 index 00000000000..a7d55e4a045 --- /dev/null +++ b/tests/baselines/reference/YieldExpression9_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts === +var v = function*() { +>v : Symbol(v, Decl(YieldExpression9_es6.ts, 0, 3)) + + yield(foo); +} diff --git a/tests/baselines/reference/YieldExpression9_es6.types b/tests/baselines/reference/YieldExpression9_es6.types new file mode 100644 index 00000000000..109dc270583 --- /dev/null +++ b/tests/baselines/reference/YieldExpression9_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts === +var v = function*() { +>v : () => IterableIterator +>function*() { yield(foo);} : () => IterableIterator + + yield(foo); +>yield(foo) : any +>(foo) : any +>foo : any +} diff --git a/tests/baselines/reference/YieldStarExpression1_es6.symbols b/tests/baselines/reference/YieldStarExpression1_es6.symbols new file mode 100644 index 00000000000..c01128e880c --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression1_es6.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts === +yield * []; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/YieldStarExpression1_es6.types b/tests/baselines/reference/YieldStarExpression1_es6.types new file mode 100644 index 00000000000..df3a2325acf --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression1_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression1_es6.ts === +yield * []; +>yield * [] : number +>yield : any +>[] : undefined[] + diff --git a/tests/baselines/reference/YieldStarExpression2_es6.symbols b/tests/baselines/reference/YieldStarExpression2_es6.symbols new file mode 100644 index 00000000000..758acfdfece --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression2_es6.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts === +yield *; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/YieldStarExpression2_es6.types b/tests/baselines/reference/YieldStarExpression2_es6.types new file mode 100644 index 00000000000..ecfd8b2d43e --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression2_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression2_es6.ts === +yield *; +>yield * : number +>yield : any +> : any + diff --git a/tests/baselines/reference/YieldStarExpression3_es6.symbols b/tests/baselines/reference/YieldStarExpression3_es6.symbols new file mode 100644 index 00000000000..5440d616c73 --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression3_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts === +function *g() { +>g : Symbol(g, Decl(YieldStarExpression3_es6.ts, 0, 0)) + + yield *; +} diff --git a/tests/baselines/reference/YieldStarExpression3_es6.types b/tests/baselines/reference/YieldStarExpression3_es6.types new file mode 100644 index 00000000000..5bc03855b19 --- /dev/null +++ b/tests/baselines/reference/YieldStarExpression3_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts === +function *g() { +>g : () => IterableIterator + + yield *; +>yield * : any +> : any +} diff --git a/tests/baselines/reference/abstractClassInLocalScopeIsAbstract.symbols b/tests/baselines/reference/abstractClassInLocalScopeIsAbstract.symbols new file mode 100644 index 00000000000..9b8ce6d417b --- /dev/null +++ b/tests/baselines/reference/abstractClassInLocalScopeIsAbstract.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/abstractClassInLocalScopeIsAbstract.ts === +(() => { + abstract class A {} +>A : Symbol(A, Decl(abstractClassInLocalScopeIsAbstract.ts, 0, 8)) + + class B extends A {} +>B : Symbol(B, Decl(abstractClassInLocalScopeIsAbstract.ts, 1, 23)) +>A : Symbol(A, Decl(abstractClassInLocalScopeIsAbstract.ts, 0, 8)) + + new A(); +>A : Symbol(A, Decl(abstractClassInLocalScopeIsAbstract.ts, 0, 8)) + + new B(); +>B : Symbol(B, Decl(abstractClassInLocalScopeIsAbstract.ts, 1, 23)) + +})() + diff --git a/tests/baselines/reference/abstractClassInLocalScopeIsAbstract.types b/tests/baselines/reference/abstractClassInLocalScopeIsAbstract.types new file mode 100644 index 00000000000..106559c7be3 --- /dev/null +++ b/tests/baselines/reference/abstractClassInLocalScopeIsAbstract.types @@ -0,0 +1,23 @@ +=== tests/cases/compiler/abstractClassInLocalScopeIsAbstract.ts === +(() => { +>(() => { abstract class A {} class B extends A {} new A(); new B();})() : void +>(() => { abstract class A {} class B extends A {} new A(); new B();}) : () => void +>() => { abstract class A {} class B extends A {} new A(); new B();} : () => void + + abstract class A {} +>A : A + + class B extends A {} +>B : B +>A : A + + new A(); +>new A() : any +>A : typeof A + + new B(); +>new B() : B +>B : typeof B + +})() + diff --git a/tests/baselines/reference/abstractPropertyNegative.symbols b/tests/baselines/reference/abstractPropertyNegative.symbols new file mode 100644 index 00000000000..16fa75b309f --- /dev/null +++ b/tests/baselines/reference/abstractPropertyNegative.symbols @@ -0,0 +1,107 @@ +=== tests/cases/compiler/abstractPropertyNegative.ts === +interface A { +>A : Symbol(A, Decl(abstractPropertyNegative.ts, 0, 0)) + + prop: string; +>prop : Symbol(A.prop, Decl(abstractPropertyNegative.ts, 0, 13)) + + m(): string; +>m : Symbol(A.m, Decl(abstractPropertyNegative.ts, 1, 17)) +} +abstract class B implements A { +>B : Symbol(B, Decl(abstractPropertyNegative.ts, 3, 1)) +>A : Symbol(A, Decl(abstractPropertyNegative.ts, 0, 0)) + + abstract prop: string; +>prop : Symbol(B.prop, Decl(abstractPropertyNegative.ts, 4, 31)) + + public abstract readonly ro: string; +>ro : Symbol(B.ro, Decl(abstractPropertyNegative.ts, 5, 26)) + + abstract get readonlyProp(): string; +>readonlyProp : Symbol(B.readonlyProp, Decl(abstractPropertyNegative.ts, 6, 40)) + + abstract m(): string; +>m : Symbol(B.m, Decl(abstractPropertyNegative.ts, 7, 40)) + + abstract get mismatch(): string; +>mismatch : Symbol(B.mismatch, Decl(abstractPropertyNegative.ts, 8, 25), Decl(abstractPropertyNegative.ts, 9, 36)) + + abstract set mismatch(val: number); // error, not same type +>mismatch : Symbol(B.mismatch, Decl(abstractPropertyNegative.ts, 8, 25), Decl(abstractPropertyNegative.ts, 9, 36)) +>val : Symbol(val, Decl(abstractPropertyNegative.ts, 10, 26)) +} +class C extends B { +>C : Symbol(C, Decl(abstractPropertyNegative.ts, 11, 1)) +>B : Symbol(B, Decl(abstractPropertyNegative.ts, 3, 1)) + + readonly ro = "readonly please"; +>ro : Symbol(C.ro, Decl(abstractPropertyNegative.ts, 12, 19)) + + abstract notAllowed: string; +>notAllowed : Symbol(C.notAllowed, Decl(abstractPropertyNegative.ts, 13, 36)) + + get concreteWithNoBody(): string; +>concreteWithNoBody : Symbol(C.concreteWithNoBody, Decl(abstractPropertyNegative.ts, 14, 32)) +} +let c = new C(); +>c : Symbol(c, Decl(abstractPropertyNegative.ts, 17, 3)) +>C : Symbol(C, Decl(abstractPropertyNegative.ts, 11, 1)) + +c.ro = "error: lhs of assignment can't be readonly"; +>c.ro : Symbol(C.ro, Decl(abstractPropertyNegative.ts, 12, 19)) +>c : Symbol(c, Decl(abstractPropertyNegative.ts, 17, 3)) +>ro : Symbol(C.ro, Decl(abstractPropertyNegative.ts, 12, 19)) + +abstract class WrongTypeProperty { +>WrongTypeProperty : Symbol(WrongTypeProperty, Decl(abstractPropertyNegative.ts, 18, 52)) + + abstract num: number; +>num : Symbol(WrongTypeProperty.num, Decl(abstractPropertyNegative.ts, 20, 34)) +} +class WrongTypePropertyImpl extends WrongTypeProperty { +>WrongTypePropertyImpl : Symbol(WrongTypePropertyImpl, Decl(abstractPropertyNegative.ts, 22, 1)) +>WrongTypeProperty : Symbol(WrongTypeProperty, Decl(abstractPropertyNegative.ts, 18, 52)) + + num = "nope, wrong"; +>num : Symbol(WrongTypePropertyImpl.num, Decl(abstractPropertyNegative.ts, 23, 55)) +} +abstract class WrongTypeAccessor { +>WrongTypeAccessor : Symbol(WrongTypeAccessor, Decl(abstractPropertyNegative.ts, 25, 1)) + + abstract get num(): number; +>num : Symbol(WrongTypeAccessor.num, Decl(abstractPropertyNegative.ts, 26, 34)) +} +class WrongTypeAccessorImpl extends WrongTypeAccessor { +>WrongTypeAccessorImpl : Symbol(WrongTypeAccessorImpl, Decl(abstractPropertyNegative.ts, 28, 1)) +>WrongTypeAccessor : Symbol(WrongTypeAccessor, Decl(abstractPropertyNegative.ts, 25, 1)) + + get num() { return "nope, wrong"; } +>num : Symbol(WrongTypeAccessorImpl.num, Decl(abstractPropertyNegative.ts, 29, 55)) +} +class WrongTypeAccessorImpl2 extends WrongTypeAccessor { +>WrongTypeAccessorImpl2 : Symbol(WrongTypeAccessorImpl2, Decl(abstractPropertyNegative.ts, 31, 1)) +>WrongTypeAccessor : Symbol(WrongTypeAccessor, Decl(abstractPropertyNegative.ts, 25, 1)) + + num = "nope, wrong"; +>num : Symbol(WrongTypeAccessorImpl2.num, Decl(abstractPropertyNegative.ts, 32, 56)) +} + +abstract class AbstractAccessorMismatch { +>AbstractAccessorMismatch : Symbol(AbstractAccessorMismatch, Decl(abstractPropertyNegative.ts, 34, 1)) + + abstract get p1(): string; +>p1 : Symbol(AbstractAccessorMismatch.p1, Decl(abstractPropertyNegative.ts, 36, 41), Decl(abstractPropertyNegative.ts, 37, 30)) + + set p1(val: string) { }; +>p1 : Symbol(AbstractAccessorMismatch.p1, Decl(abstractPropertyNegative.ts, 36, 41), Decl(abstractPropertyNegative.ts, 37, 30)) +>val : Symbol(val, Decl(abstractPropertyNegative.ts, 38, 11)) + + get p2(): string { return "should work"; } +>p2 : Symbol(AbstractAccessorMismatch.p2, Decl(abstractPropertyNegative.ts, 38, 28), Decl(abstractPropertyNegative.ts, 39, 46)) + + abstract set p2(val: string); +>p2 : Symbol(AbstractAccessorMismatch.p2, Decl(abstractPropertyNegative.ts, 38, 28), Decl(abstractPropertyNegative.ts, 39, 46)) +>val : Symbol(val, Decl(abstractPropertyNegative.ts, 40, 20)) +} + diff --git a/tests/baselines/reference/abstractPropertyNegative.types b/tests/baselines/reference/abstractPropertyNegative.types new file mode 100644 index 00000000000..371a84e8e91 --- /dev/null +++ b/tests/baselines/reference/abstractPropertyNegative.types @@ -0,0 +1,115 @@ +=== tests/cases/compiler/abstractPropertyNegative.ts === +interface A { +>A : A + + prop: string; +>prop : string + + m(): string; +>m : () => string +} +abstract class B implements A { +>B : B +>A : A + + abstract prop: string; +>prop : string + + public abstract readonly ro: string; +>ro : string + + abstract get readonlyProp(): string; +>readonlyProp : string + + abstract m(): string; +>m : () => string + + abstract get mismatch(): string; +>mismatch : string + + abstract set mismatch(val: number); // error, not same type +>mismatch : string +>val : number +} +class C extends B { +>C : C +>B : B + + readonly ro = "readonly please"; +>ro : "readonly please" +>"readonly please" : "readonly please" + + abstract notAllowed: string; +>notAllowed : string + + get concreteWithNoBody(): string; +>concreteWithNoBody : string +} +let c = new C(); +>c : C +>new C() : C +>C : typeof C + +c.ro = "error: lhs of assignment can't be readonly"; +>c.ro = "error: lhs of assignment can't be readonly" : "error: lhs of assignment can't be readonly" +>c.ro : any +>c : C +>ro : any +>"error: lhs of assignment can't be readonly" : "error: lhs of assignment can't be readonly" + +abstract class WrongTypeProperty { +>WrongTypeProperty : WrongTypeProperty + + abstract num: number; +>num : number +} +class WrongTypePropertyImpl extends WrongTypeProperty { +>WrongTypePropertyImpl : WrongTypePropertyImpl +>WrongTypeProperty : WrongTypeProperty + + num = "nope, wrong"; +>num : string +>"nope, wrong" : "nope, wrong" +} +abstract class WrongTypeAccessor { +>WrongTypeAccessor : WrongTypeAccessor + + abstract get num(): number; +>num : number +} +class WrongTypeAccessorImpl extends WrongTypeAccessor { +>WrongTypeAccessorImpl : WrongTypeAccessorImpl +>WrongTypeAccessor : WrongTypeAccessor + + get num() { return "nope, wrong"; } +>num : string +>"nope, wrong" : "nope, wrong" +} +class WrongTypeAccessorImpl2 extends WrongTypeAccessor { +>WrongTypeAccessorImpl2 : WrongTypeAccessorImpl2 +>WrongTypeAccessor : WrongTypeAccessor + + num = "nope, wrong"; +>num : string +>"nope, wrong" : "nope, wrong" +} + +abstract class AbstractAccessorMismatch { +>AbstractAccessorMismatch : AbstractAccessorMismatch + + abstract get p1(): string; +>p1 : string + + set p1(val: string) { }; +>p1 : string +>val : string + + get p2(): string { return "should work"; } +>p2 : string +>"should work" : "should work" + + abstract set p2(val: string); +>p2 : string +>val : string +} + diff --git a/tests/baselines/reference/accessInstanceMemberFromStaticMethod01.symbols b/tests/baselines/reference/accessInstanceMemberFromStaticMethod01.symbols new file mode 100644 index 00000000000..3c311ab6fab --- /dev/null +++ b/tests/baselines/reference/accessInstanceMemberFromStaticMethod01.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/accessInstanceMemberFromStaticMethod01.ts === +class C { +>C : Symbol(C, Decl(accessInstanceMemberFromStaticMethod01.ts, 0, 0)) + + static foo: string; +>foo : Symbol(C.foo, Decl(accessInstanceMemberFromStaticMethod01.ts, 0, 9)) + + bar() { +>bar : Symbol(C.bar, Decl(accessInstanceMemberFromStaticMethod01.ts, 1, 23)) + + let k = foo; +>k : Symbol(k, Decl(accessInstanceMemberFromStaticMethod01.ts, 4, 11)) + } +} diff --git a/tests/baselines/reference/accessInstanceMemberFromStaticMethod01.types b/tests/baselines/reference/accessInstanceMemberFromStaticMethod01.types new file mode 100644 index 00000000000..a0538378bd5 --- /dev/null +++ b/tests/baselines/reference/accessInstanceMemberFromStaticMethod01.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/accessInstanceMemberFromStaticMethod01.ts === +class C { +>C : C + + static foo: string; +>foo : string + + bar() { +>bar : () => void + + let k = foo; +>k : any +>foo : any + } +} diff --git a/tests/baselines/reference/accessStaticMemberFromInstanceMethod01.symbols b/tests/baselines/reference/accessStaticMemberFromInstanceMethod01.symbols new file mode 100644 index 00000000000..f805a90ccc4 --- /dev/null +++ b/tests/baselines/reference/accessStaticMemberFromInstanceMethod01.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/accessStaticMemberFromInstanceMethod01.ts === +class C { +>C : Symbol(C, Decl(accessStaticMemberFromInstanceMethod01.ts, 0, 0)) + + foo: string; +>foo : Symbol(C.foo, Decl(accessStaticMemberFromInstanceMethod01.ts, 0, 9)) + + static bar() { +>bar : Symbol(C.bar, Decl(accessStaticMemberFromInstanceMethod01.ts, 1, 16)) + + let k = foo; +>k : Symbol(k, Decl(accessStaticMemberFromInstanceMethod01.ts, 4, 11)) + } +} diff --git a/tests/baselines/reference/accessStaticMemberFromInstanceMethod01.types b/tests/baselines/reference/accessStaticMemberFromInstanceMethod01.types new file mode 100644 index 00000000000..7411ba1de69 --- /dev/null +++ b/tests/baselines/reference/accessStaticMemberFromInstanceMethod01.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/accessStaticMemberFromInstanceMethod01.ts === +class C { +>C : C + + foo: string; +>foo : string + + static bar() { +>bar : () => void + + let k = foo; +>k : any +>foo : any + } +} diff --git a/tests/baselines/reference/accessibilityModifiers.symbols b/tests/baselines/reference/accessibilityModifiers.symbols new file mode 100644 index 00000000000..09548fe13a1 --- /dev/null +++ b/tests/baselines/reference/accessibilityModifiers.symbols @@ -0,0 +1,107 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts === +// No errors +class C { +>C : Symbol(C, Decl(accessibilityModifiers.ts, 0, 0)) + + private static privateProperty; +>privateProperty : Symbol(C.privateProperty, Decl(accessibilityModifiers.ts, 1, 9)) + + private static privateMethod() { } +>privateMethod : Symbol(C.privateMethod, Decl(accessibilityModifiers.ts, 2, 35)) + + private static get privateGetter() { return 0; } +>privateGetter : Symbol(C.privateGetter, Decl(accessibilityModifiers.ts, 3, 38)) + + private static set privateSetter(a: number) { } +>privateSetter : Symbol(C.privateSetter, Decl(accessibilityModifiers.ts, 4, 52)) +>a : Symbol(a, Decl(accessibilityModifiers.ts, 5, 37)) + + protected static protectedProperty; +>protectedProperty : Symbol(C.protectedProperty, Decl(accessibilityModifiers.ts, 5, 51)) + + protected static protectedMethod() { } +>protectedMethod : Symbol(C.protectedMethod, Decl(accessibilityModifiers.ts, 7, 39)) + + protected static get protectedGetter() { return 0; } +>protectedGetter : Symbol(C.protectedGetter, Decl(accessibilityModifiers.ts, 8, 42)) + + protected static set protectedSetter(a: number) { } +>protectedSetter : Symbol(C.protectedSetter, Decl(accessibilityModifiers.ts, 9, 56)) +>a : Symbol(a, Decl(accessibilityModifiers.ts, 10, 41)) + + public static publicProperty; +>publicProperty : Symbol(C.publicProperty, Decl(accessibilityModifiers.ts, 10, 55)) + + public static publicMethod() { } +>publicMethod : Symbol(C.publicMethod, Decl(accessibilityModifiers.ts, 12, 33)) + + public static get publicGetter() { return 0; } +>publicGetter : Symbol(C.publicGetter, Decl(accessibilityModifiers.ts, 13, 36)) + + public static set publicSetter(a: number) { } +>publicSetter : Symbol(C.publicSetter, Decl(accessibilityModifiers.ts, 14, 50)) +>a : Symbol(a, Decl(accessibilityModifiers.ts, 15, 35)) +} + +// Errors, accessibility modifiers must precede static +class D { +>D : Symbol(D, Decl(accessibilityModifiers.ts, 16, 1)) + + static private privateProperty; +>privateProperty : Symbol(D.privateProperty, Decl(accessibilityModifiers.ts, 19, 9)) + + static private privateMethod() { } +>privateMethod : Symbol(D.privateMethod, Decl(accessibilityModifiers.ts, 20, 35)) + + static private get privateGetter() { return 0; } +>privateGetter : Symbol(D.privateGetter, Decl(accessibilityModifiers.ts, 21, 38)) + + static private set privateSetter(a: number) { } +>privateSetter : Symbol(D.privateSetter, Decl(accessibilityModifiers.ts, 22, 52)) +>a : Symbol(a, Decl(accessibilityModifiers.ts, 23, 37)) + + static protected protectedProperty; +>protectedProperty : Symbol(D.protectedProperty, Decl(accessibilityModifiers.ts, 23, 51)) + + static protected protectedMethod() { } +>protectedMethod : Symbol(D.protectedMethod, Decl(accessibilityModifiers.ts, 25, 39)) + + static protected get protectedGetter() { return 0; } +>protectedGetter : Symbol(D.protectedGetter, Decl(accessibilityModifiers.ts, 26, 42)) + + static protected set protectedSetter(a: number) { } +>protectedSetter : Symbol(D.protectedSetter, Decl(accessibilityModifiers.ts, 27, 56)) +>a : Symbol(a, Decl(accessibilityModifiers.ts, 28, 41)) + + static public publicProperty; +>publicProperty : Symbol(D.publicProperty, Decl(accessibilityModifiers.ts, 28, 55)) + + static public publicMethod() { } +>publicMethod : Symbol(D.publicMethod, Decl(accessibilityModifiers.ts, 30, 33)) + + static public get publicGetter() { return 0; } +>publicGetter : Symbol(D.publicGetter, Decl(accessibilityModifiers.ts, 31, 36)) + + static public set publicSetter(a: number) { } +>publicSetter : Symbol(D.publicSetter, Decl(accessibilityModifiers.ts, 32, 50)) +>a : Symbol(a, Decl(accessibilityModifiers.ts, 33, 35)) +} + +// Errors, multiple accessibility modifier +class E { +>E : Symbol(E, Decl(accessibilityModifiers.ts, 34, 1)) + + private public protected property; +>property : Symbol(E.property, Decl(accessibilityModifiers.ts, 37, 9)) + + public protected method() { } +>method : Symbol(E.method, Decl(accessibilityModifiers.ts, 38, 38)) + + private protected get getter() { return 0; } +>getter : Symbol(E.getter, Decl(accessibilityModifiers.ts, 39, 33)) + + public public set setter(a: number) { } +>setter : Symbol(E.setter, Decl(accessibilityModifiers.ts, 40, 48)) +>a : Symbol(a, Decl(accessibilityModifiers.ts, 41, 29)) +} + diff --git a/tests/baselines/reference/accessibilityModifiers.types b/tests/baselines/reference/accessibilityModifiers.types new file mode 100644 index 00000000000..5dd3f3b7608 --- /dev/null +++ b/tests/baselines/reference/accessibilityModifiers.types @@ -0,0 +1,114 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/accessibilityModifiers.ts === +// No errors +class C { +>C : C + + private static privateProperty; +>privateProperty : any + + private static privateMethod() { } +>privateMethod : () => void + + private static get privateGetter() { return 0; } +>privateGetter : number +>0 : 0 + + private static set privateSetter(a: number) { } +>privateSetter : number +>a : number + + protected static protectedProperty; +>protectedProperty : any + + protected static protectedMethod() { } +>protectedMethod : () => void + + protected static get protectedGetter() { return 0; } +>protectedGetter : number +>0 : 0 + + protected static set protectedSetter(a: number) { } +>protectedSetter : number +>a : number + + public static publicProperty; +>publicProperty : any + + public static publicMethod() { } +>publicMethod : () => void + + public static get publicGetter() { return 0; } +>publicGetter : number +>0 : 0 + + public static set publicSetter(a: number) { } +>publicSetter : number +>a : number +} + +// Errors, accessibility modifiers must precede static +class D { +>D : D + + static private privateProperty; +>privateProperty : any + + static private privateMethod() { } +>privateMethod : () => void + + static private get privateGetter() { return 0; } +>privateGetter : number +>0 : 0 + + static private set privateSetter(a: number) { } +>privateSetter : number +>a : number + + static protected protectedProperty; +>protectedProperty : any + + static protected protectedMethod() { } +>protectedMethod : () => void + + static protected get protectedGetter() { return 0; } +>protectedGetter : number +>0 : 0 + + static protected set protectedSetter(a: number) { } +>protectedSetter : number +>a : number + + static public publicProperty; +>publicProperty : any + + static public publicMethod() { } +>publicMethod : () => void + + static public get publicGetter() { return 0; } +>publicGetter : number +>0 : 0 + + static public set publicSetter(a: number) { } +>publicSetter : number +>a : number +} + +// Errors, multiple accessibility modifier +class E { +>E : E + + private public protected property; +>property : any + + public protected method() { } +>method : () => void + + private protected get getter() { return 0; } +>getter : number +>0 : 0 + + public public set setter(a: number) { } +>setter : number +>a : number +} + diff --git a/tests/baselines/reference/accessorParameterAccessibilityModifier.symbols b/tests/baselines/reference/accessorParameterAccessibilityModifier.symbols new file mode 100644 index 00000000000..76290d8d209 --- /dev/null +++ b/tests/baselines/reference/accessorParameterAccessibilityModifier.symbols @@ -0,0 +1,12 @@ +=== tests/cases/compiler/accessorParameterAccessibilityModifier.ts === +class C { +>C : Symbol(C, Decl(accessorParameterAccessibilityModifier.ts, 0, 0)) + + set X(public v) { } +>X : Symbol(C.X, Decl(accessorParameterAccessibilityModifier.ts, 0, 9)) +>v : Symbol(v, Decl(accessorParameterAccessibilityModifier.ts, 1, 10)) + + static set X(public v2) { } +>X : Symbol(C.X, Decl(accessorParameterAccessibilityModifier.ts, 1, 23)) +>v2 : Symbol(v2, Decl(accessorParameterAccessibilityModifier.ts, 2, 17)) +} diff --git a/tests/baselines/reference/accessorParameterAccessibilityModifier.types b/tests/baselines/reference/accessorParameterAccessibilityModifier.types new file mode 100644 index 00000000000..0201a9d60ee --- /dev/null +++ b/tests/baselines/reference/accessorParameterAccessibilityModifier.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/accessorParameterAccessibilityModifier.ts === +class C { +>C : C + + set X(public v) { } +>X : any +>v : any + + static set X(public v2) { } +>X : any +>v2 : any +} diff --git a/tests/baselines/reference/accessorWithES3.symbols b/tests/baselines/reference/accessorWithES3.symbols new file mode 100644 index 00000000000..5b1e0cae1b7 --- /dev/null +++ b/tests/baselines/reference/accessorWithES3.symbols @@ -0,0 +1,36 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts === +// error to use accessors in ES3 mode + +class C { +>C : Symbol(C, Decl(accessorWithES3.ts, 0, 0)) + + get x() { +>x : Symbol(C.x, Decl(accessorWithES3.ts, 2, 9)) + + return 1; + } +} + +class D { +>D : Symbol(D, Decl(accessorWithES3.ts, 6, 1)) + + set x(v) { +>x : Symbol(D.x, Decl(accessorWithES3.ts, 8, 9)) +>v : Symbol(v, Decl(accessorWithES3.ts, 9, 10)) + } +} + +var x = { +>x : Symbol(x, Decl(accessorWithES3.ts, 13, 3)) + + get a() { return 1 } +>a : Symbol(a, Decl(accessorWithES3.ts, 13, 9)) +} + +var y = { +>y : Symbol(y, Decl(accessorWithES3.ts, 17, 3)) + + set b(v) { } +>b : Symbol(b, Decl(accessorWithES3.ts, 17, 9)) +>v : Symbol(v, Decl(accessorWithES3.ts, 18, 10)) +} diff --git a/tests/baselines/reference/accessorWithES3.types b/tests/baselines/reference/accessorWithES3.types new file mode 100644 index 00000000000..b3c8353b96c --- /dev/null +++ b/tests/baselines/reference/accessorWithES3.types @@ -0,0 +1,40 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES3.ts === +// error to use accessors in ES3 mode + +class C { +>C : C + + get x() { +>x : number + + return 1; +>1 : 1 + } +} + +class D { +>D : D + + set x(v) { +>x : any +>v : any + } +} + +var x = { +>x : { readonly a: number; } +>{ get a() { return 1 }} : { readonly a: number; } + + get a() { return 1 } +>a : number +>1 : 1 +} + +var y = { +>y : { b: any; } +>{ set b(v) { }} : { b: any; } + + set b(v) { } +>b : any +>v : any +} diff --git a/tests/baselines/reference/accessorWithInitializer.symbols b/tests/baselines/reference/accessorWithInitializer.symbols new file mode 100644 index 00000000000..7bf6716f146 --- /dev/null +++ b/tests/baselines/reference/accessorWithInitializer.symbols @@ -0,0 +1,12 @@ +=== tests/cases/compiler/accessorWithInitializer.ts === +class C { +>C : Symbol(C, Decl(accessorWithInitializer.ts, 0, 0)) + + set X(v = 0) { } +>X : Symbol(C.X, Decl(accessorWithInitializer.ts, 0, 9)) +>v : Symbol(v, Decl(accessorWithInitializer.ts, 1, 10)) + + static set X(v2 = 0) { } +>X : Symbol(C.X, Decl(accessorWithInitializer.ts, 1, 20)) +>v2 : Symbol(v2, Decl(accessorWithInitializer.ts, 2, 17)) +} diff --git a/tests/baselines/reference/accessorWithInitializer.types b/tests/baselines/reference/accessorWithInitializer.types new file mode 100644 index 00000000000..407bf158d1c --- /dev/null +++ b/tests/baselines/reference/accessorWithInitializer.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/accessorWithInitializer.ts === +class C { +>C : C + + set X(v = 0) { } +>X : any +>v : number +>0 : 0 + + static set X(v2 = 0) { } +>X : any +>v2 : number +>0 : 0 +} diff --git a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.symbols b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.symbols new file mode 100644 index 00000000000..b3c626c0283 --- /dev/null +++ b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.symbols @@ -0,0 +1,56 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts === +class C { +>C : Symbol(C, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 0, 0)) + + get x() { +>x : Symbol(C.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 0, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 3, 5)) + + return 1; + } + private set x(v) { +>x : Symbol(C.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 0, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 3, 5)) +>v : Symbol(v, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 4, 18)) + } +} + +class D { +>D : Symbol(D, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 6, 1)) + + protected get x() { +>x : Symbol(D.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 8, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 11, 5)) + + return 1; + } + private set x(v) { +>x : Symbol(D.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 8, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 11, 5)) +>v : Symbol(v, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 12, 18)) + } +} + +class E { +>E : Symbol(E, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 14, 1)) + + protected set x(v) { +>x : Symbol(E.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 16, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 18, 5)) +>v : Symbol(v, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 17, 20)) + } + get x() { +>x : Symbol(E.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 16, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 18, 5)) + + return 1; + } +} + +class F { +>F : Symbol(F, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 22, 1)) + + protected static set x(v) { +>x : Symbol(F.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 24, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 26, 5)) +>v : Symbol(v, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 25, 27)) + } + static get x() { +>x : Symbol(F.x, Decl(accessorWithMismatchedAccessibilityModifiers.ts, 24, 9), Decl(accessorWithMismatchedAccessibilityModifiers.ts, 26, 5)) + + return 1; + } +} diff --git a/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.types b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.types new file mode 100644 index 00000000000..82902331573 --- /dev/null +++ b/tests/baselines/reference/accessorWithMismatchedAccessibilityModifiers.types @@ -0,0 +1,60 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithMismatchedAccessibilityModifiers.ts === +class C { +>C : C + + get x() { +>x : number + + return 1; +>1 : 1 + } + private set x(v) { +>x : number +>v : number + } +} + +class D { +>D : D + + protected get x() { +>x : number + + return 1; +>1 : 1 + } + private set x(v) { +>x : number +>v : number + } +} + +class E { +>E : E + + protected set x(v) { +>x : number +>v : number + } + get x() { +>x : number + + return 1; +>1 : 1 + } +} + +class F { +>F : F + + protected static set x(v) { +>x : number +>v : number + } + static get x() { +>x : number + + return 1; +>1 : 1 + } +} diff --git a/tests/baselines/reference/accessorWithRestParam.symbols b/tests/baselines/reference/accessorWithRestParam.symbols new file mode 100644 index 00000000000..204df594b24 --- /dev/null +++ b/tests/baselines/reference/accessorWithRestParam.symbols @@ -0,0 +1,12 @@ +=== tests/cases/compiler/accessorWithRestParam.ts === +class C { +>C : Symbol(C, Decl(accessorWithRestParam.ts, 0, 0)) + + set X(...v) { } +>X : Symbol(C.X, Decl(accessorWithRestParam.ts, 0, 9)) +>v : Symbol(v, Decl(accessorWithRestParam.ts, 1, 10)) + + static set X(...v2) { } +>X : Symbol(C.X, Decl(accessorWithRestParam.ts, 1, 19)) +>v2 : Symbol(v2, Decl(accessorWithRestParam.ts, 2, 17)) +} diff --git a/tests/baselines/reference/accessorWithRestParam.types b/tests/baselines/reference/accessorWithRestParam.types new file mode 100644 index 00000000000..d447c1693d1 --- /dev/null +++ b/tests/baselines/reference/accessorWithRestParam.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/accessorWithRestParam.ts === +class C { +>C : C + + set X(...v) { } +>X : any +>v : any[] + + static set X(...v2) { } +>X : any +>v2 : any[] +} diff --git a/tests/baselines/reference/accessorWithoutBody1.symbols b/tests/baselines/reference/accessorWithoutBody1.symbols new file mode 100644 index 00000000000..8b7b5f4fc6d --- /dev/null +++ b/tests/baselines/reference/accessorWithoutBody1.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/accessorWithoutBody1.ts === +var v = { get foo() } +>v : Symbol(v, Decl(accessorWithoutBody1.ts, 0, 3)) +>foo : Symbol(foo, Decl(accessorWithoutBody1.ts, 0, 9)) + diff --git a/tests/baselines/reference/accessorWithoutBody1.types b/tests/baselines/reference/accessorWithoutBody1.types new file mode 100644 index 00000000000..aa70f78e120 --- /dev/null +++ b/tests/baselines/reference/accessorWithoutBody1.types @@ -0,0 +1,6 @@ +=== tests/cases/compiler/accessorWithoutBody1.ts === +var v = { get foo() } +>v : { readonly foo: any; } +>{ get foo() } : { readonly foo: any; } +>foo : any + diff --git a/tests/baselines/reference/accessorWithoutBody2.symbols b/tests/baselines/reference/accessorWithoutBody2.symbols new file mode 100644 index 00000000000..242f59a7f50 --- /dev/null +++ b/tests/baselines/reference/accessorWithoutBody2.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/accessorWithoutBody2.ts === +var v = { set foo(a) } +>v : Symbol(v, Decl(accessorWithoutBody2.ts, 0, 3)) +>foo : Symbol(foo, Decl(accessorWithoutBody2.ts, 0, 9)) +>a : Symbol(a, Decl(accessorWithoutBody2.ts, 0, 18)) + diff --git a/tests/baselines/reference/accessorWithoutBody2.types b/tests/baselines/reference/accessorWithoutBody2.types new file mode 100644 index 00000000000..19e9b941ead --- /dev/null +++ b/tests/baselines/reference/accessorWithoutBody2.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/accessorWithoutBody2.ts === +var v = { set foo(a) } +>v : { foo: any; } +>{ set foo(a) } : { foo: any; } +>foo : any +>a : any + diff --git a/tests/baselines/reference/accessorsAreNotContextuallyTyped.symbols b/tests/baselines/reference/accessorsAreNotContextuallyTyped.symbols new file mode 100644 index 00000000000..0589eb7f4a8 --- /dev/null +++ b/tests/baselines/reference/accessorsAreNotContextuallyTyped.symbols @@ -0,0 +1,30 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorsAreNotContextuallyTyped.ts === +// accessors are not contextually typed + +class C { +>C : Symbol(C, Decl(accessorsAreNotContextuallyTyped.ts, 0, 0)) + + set x(v: (a: string) => string) { +>x : Symbol(C.x, Decl(accessorsAreNotContextuallyTyped.ts, 2, 9), Decl(accessorsAreNotContextuallyTyped.ts, 4, 5)) +>v : Symbol(v, Decl(accessorsAreNotContextuallyTyped.ts, 3, 10)) +>a : Symbol(a, Decl(accessorsAreNotContextuallyTyped.ts, 3, 14)) + } + + get x() { +>x : Symbol(C.x, Decl(accessorsAreNotContextuallyTyped.ts, 2, 9), Decl(accessorsAreNotContextuallyTyped.ts, 4, 5)) + + return (x: string) => ""; +>x : Symbol(x, Decl(accessorsAreNotContextuallyTyped.ts, 7, 16)) + } +} + +var c: C; +>c : Symbol(c, Decl(accessorsAreNotContextuallyTyped.ts, 11, 3)) +>C : Symbol(C, Decl(accessorsAreNotContextuallyTyped.ts, 0, 0)) + +var r = c.x(''); // string +>r : Symbol(r, Decl(accessorsAreNotContextuallyTyped.ts, 12, 3)) +>c.x : Symbol(C.x, Decl(accessorsAreNotContextuallyTyped.ts, 2, 9), Decl(accessorsAreNotContextuallyTyped.ts, 4, 5)) +>c : Symbol(c, Decl(accessorsAreNotContextuallyTyped.ts, 11, 3)) +>x : Symbol(C.x, Decl(accessorsAreNotContextuallyTyped.ts, 2, 9), Decl(accessorsAreNotContextuallyTyped.ts, 4, 5)) + diff --git a/tests/baselines/reference/accessorsAreNotContextuallyTyped.types b/tests/baselines/reference/accessorsAreNotContextuallyTyped.types new file mode 100644 index 00000000000..c48ad593724 --- /dev/null +++ b/tests/baselines/reference/accessorsAreNotContextuallyTyped.types @@ -0,0 +1,34 @@ +=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorsAreNotContextuallyTyped.ts === +// accessors are not contextually typed + +class C { +>C : C + + set x(v: (a: string) => string) { +>x : (a: string) => string +>v : (a: string) => string +>a : string + } + + get x() { +>x : (a: string) => string + + return (x: string) => ""; +>(x: string) => "" : (x: string) => string +>x : string +>"" : "" + } +} + +var c: C; +>c : C +>C : C + +var r = c.x(''); // string +>r : string +>c.x('') : string +>c.x : (a: string) => string +>c : C +>x : (a: string) => string +>'' : "" + diff --git a/tests/baselines/reference/accessorsEmit.symbols b/tests/baselines/reference/accessorsEmit.symbols new file mode 100644 index 00000000000..119d81d369a --- /dev/null +++ b/tests/baselines/reference/accessorsEmit.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/accessorsEmit.ts === +class Result { } +>Result : Symbol(Result, Decl(accessorsEmit.ts, 0, 0)) + +class Test { +>Test : Symbol(Test, Decl(accessorsEmit.ts, 0, 16)) + + get Property(): Result { +>Property : Symbol(Test.Property, Decl(accessorsEmit.ts, 2, 12)) +>Result : Symbol(Result, Decl(accessorsEmit.ts, 0, 0)) + + var x = 1; +>x : Symbol(x, Decl(accessorsEmit.ts, 4, 11)) + + return null; + } +} + +class Test2 { +>Test2 : Symbol(Test2, Decl(accessorsEmit.ts, 7, 1)) + + get Property() { +>Property : Symbol(Test2.Property, Decl(accessorsEmit.ts, 9, 13)) + + var x = 1; +>x : Symbol(x, Decl(accessorsEmit.ts, 11, 11)) + + return null; + } +} diff --git a/tests/baselines/reference/accessorsEmit.types b/tests/baselines/reference/accessorsEmit.types new file mode 100644 index 00000000000..84759cefe87 --- /dev/null +++ b/tests/baselines/reference/accessorsEmit.types @@ -0,0 +1,34 @@ +=== tests/cases/compiler/accessorsEmit.ts === +class Result { } +>Result : Result + +class Test { +>Test : Test + + get Property(): Result { +>Property : Result +>Result : Result + + var x = 1; +>x : number +>1 : 1 + + return null; +>null : null + } +} + +class Test2 { +>Test2 : Test2 + + get Property() { +>Property : any + + var x = 1; +>x : number +>1 : 1 + + return null; +>null : null + } +} diff --git a/tests/baselines/reference/accessorsInAmbientContext.symbols b/tests/baselines/reference/accessorsInAmbientContext.symbols new file mode 100644 index 00000000000..4e19cd08f55 --- /dev/null +++ b/tests/baselines/reference/accessorsInAmbientContext.symbols @@ -0,0 +1,40 @@ +=== tests/cases/compiler/accessorsInAmbientContext.ts === +declare module M { +>M : Symbol(M, Decl(accessorsInAmbientContext.ts, 0, 0)) + + class C { +>C : Symbol(C, Decl(accessorsInAmbientContext.ts, 0, 18)) + + get X() { return 1; } +>X : Symbol(C.X, Decl(accessorsInAmbientContext.ts, 1, 13), Decl(accessorsInAmbientContext.ts, 2, 29)) + + set X(v) { } +>X : Symbol(C.X, Decl(accessorsInAmbientContext.ts, 1, 13), Decl(accessorsInAmbientContext.ts, 2, 29)) +>v : Symbol(v, Decl(accessorsInAmbientContext.ts, 3, 14)) + + static get Y() { return 1; } +>Y : Symbol(C.Y, Decl(accessorsInAmbientContext.ts, 3, 20), Decl(accessorsInAmbientContext.ts, 5, 36)) + + static set Y(v) { } +>Y : Symbol(C.Y, Decl(accessorsInAmbientContext.ts, 3, 20), Decl(accessorsInAmbientContext.ts, 5, 36)) +>v : Symbol(v, Decl(accessorsInAmbientContext.ts, 6, 21)) + } +} + +declare class C { +>C : Symbol(C, Decl(accessorsInAmbientContext.ts, 8, 1)) + + get X() { return 1; } +>X : Symbol(C.X, Decl(accessorsInAmbientContext.ts, 10, 17), Decl(accessorsInAmbientContext.ts, 11, 25)) + + set X(v) { } +>X : Symbol(C.X, Decl(accessorsInAmbientContext.ts, 10, 17), Decl(accessorsInAmbientContext.ts, 11, 25)) +>v : Symbol(v, Decl(accessorsInAmbientContext.ts, 12, 10)) + + static get Y() { return 1; } +>Y : Symbol(C.Y, Decl(accessorsInAmbientContext.ts, 12, 16), Decl(accessorsInAmbientContext.ts, 14, 32)) + + static set Y(v) { } +>Y : Symbol(C.Y, Decl(accessorsInAmbientContext.ts, 12, 16), Decl(accessorsInAmbientContext.ts, 14, 32)) +>v : Symbol(v, Decl(accessorsInAmbientContext.ts, 15, 17)) +} diff --git a/tests/baselines/reference/accessorsInAmbientContext.types b/tests/baselines/reference/accessorsInAmbientContext.types new file mode 100644 index 00000000000..fd21b158ac3 --- /dev/null +++ b/tests/baselines/reference/accessorsInAmbientContext.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/accessorsInAmbientContext.ts === +declare module M { +>M : typeof M + + class C { +>C : C + + get X() { return 1; } +>X : number +>1 : 1 + + set X(v) { } +>X : number +>v : number + + static get Y() { return 1; } +>Y : number +>1 : 1 + + static set Y(v) { } +>Y : number +>v : number + } +} + +declare class C { +>C : C + + get X() { return 1; } +>X : number +>1 : 1 + + set X(v) { } +>X : number +>v : number + + static get Y() { return 1; } +>Y : number +>1 : 1 + + static set Y(v) { } +>Y : number +>v : number +} diff --git a/tests/baselines/reference/accessorsNotAllowedInES3.symbols b/tests/baselines/reference/accessorsNotAllowedInES3.symbols new file mode 100644 index 00000000000..fc527434f35 --- /dev/null +++ b/tests/baselines/reference/accessorsNotAllowedInES3.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/accessorsNotAllowedInES3.ts === +class C { +>C : Symbol(C, Decl(accessorsNotAllowedInES3.ts, 0, 0)) + + get x(): number { return 1; } +>x : Symbol(C.x, Decl(accessorsNotAllowedInES3.ts, 0, 9)) +} +var y = { get foo() { return 3; } }; +>y : Symbol(y, Decl(accessorsNotAllowedInES3.ts, 3, 3)) +>foo : Symbol(foo, Decl(accessorsNotAllowedInES3.ts, 3, 9)) + diff --git a/tests/baselines/reference/accessorsNotAllowedInES3.types b/tests/baselines/reference/accessorsNotAllowedInES3.types new file mode 100644 index 00000000000..d83911586aa --- /dev/null +++ b/tests/baselines/reference/accessorsNotAllowedInES3.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/accessorsNotAllowedInES3.ts === +class C { +>C : C + + get x(): number { return 1; } +>x : number +>1 : 1 +} +var y = { get foo() { return 3; } }; +>y : { readonly foo: number; } +>{ get foo() { return 3; } } : { readonly foo: number; } +>foo : number +>3 : 3 + diff --git a/tests/baselines/reference/accessors_spec_section-4.5_error-cases.symbols b/tests/baselines/reference/accessors_spec_section-4.5_error-cases.symbols new file mode 100644 index 00000000000..0e8b5ab7b9a --- /dev/null +++ b/tests/baselines/reference/accessors_spec_section-4.5_error-cases.symbols @@ -0,0 +1,34 @@ +=== tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts === +class LanguageSpec_section_4_5_error_cases { +>LanguageSpec_section_4_5_error_cases : Symbol(LanguageSpec_section_4_5_error_cases, Decl(accessors_spec_section-4.5_error-cases.ts, 0, 0)) + + public set AnnotatedSetter_SetterFirst(a: number) { } +>AnnotatedSetter_SetterFirst : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedSetter_SetterFirst, Decl(accessors_spec_section-4.5_error-cases.ts, 0, 44), Decl(accessors_spec_section-4.5_error-cases.ts, 1, 57)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_error-cases.ts, 1, 43)) + + public get AnnotatedSetter_SetterFirst() { return ""; } +>AnnotatedSetter_SetterFirst : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedSetter_SetterFirst, Decl(accessors_spec_section-4.5_error-cases.ts, 0, 44), Decl(accessors_spec_section-4.5_error-cases.ts, 1, 57)) + + public get AnnotatedSetter_SetterLast() { return ""; } +>AnnotatedSetter_SetterLast : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedSetter_SetterLast, Decl(accessors_spec_section-4.5_error-cases.ts, 2, 59), Decl(accessors_spec_section-4.5_error-cases.ts, 4, 58)) + + public set AnnotatedSetter_SetterLast(a: number) { } +>AnnotatedSetter_SetterLast : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedSetter_SetterLast, Decl(accessors_spec_section-4.5_error-cases.ts, 2, 59), Decl(accessors_spec_section-4.5_error-cases.ts, 4, 58)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_error-cases.ts, 5, 42)) + + public get AnnotatedGetter_GetterFirst(): string { return ""; } +>AnnotatedGetter_GetterFirst : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedGetter_GetterFirst, Decl(accessors_spec_section-4.5_error-cases.ts, 5, 56), Decl(accessors_spec_section-4.5_error-cases.ts, 7, 67)) + + public set AnnotatedGetter_GetterFirst(aStr) { aStr = 0; } +>AnnotatedGetter_GetterFirst : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedGetter_GetterFirst, Decl(accessors_spec_section-4.5_error-cases.ts, 5, 56), Decl(accessors_spec_section-4.5_error-cases.ts, 7, 67)) +>aStr : Symbol(aStr, Decl(accessors_spec_section-4.5_error-cases.ts, 8, 43)) +>aStr : Symbol(aStr, Decl(accessors_spec_section-4.5_error-cases.ts, 8, 43)) + + public set AnnotatedGetter_GetterLast(aStr) { aStr = 0; } +>AnnotatedGetter_GetterLast : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedGetter_GetterLast, Decl(accessors_spec_section-4.5_error-cases.ts, 8, 62), Decl(accessors_spec_section-4.5_error-cases.ts, 10, 61)) +>aStr : Symbol(aStr, Decl(accessors_spec_section-4.5_error-cases.ts, 10, 42)) +>aStr : Symbol(aStr, Decl(accessors_spec_section-4.5_error-cases.ts, 10, 42)) + + public get AnnotatedGetter_GetterLast(): string { return ""; } +>AnnotatedGetter_GetterLast : Symbol(LanguageSpec_section_4_5_error_cases.AnnotatedGetter_GetterLast, Decl(accessors_spec_section-4.5_error-cases.ts, 8, 62), Decl(accessors_spec_section-4.5_error-cases.ts, 10, 61)) +} diff --git a/tests/baselines/reference/accessors_spec_section-4.5_error-cases.types b/tests/baselines/reference/accessors_spec_section-4.5_error-cases.types new file mode 100644 index 00000000000..1fd475c579c --- /dev/null +++ b/tests/baselines/reference/accessors_spec_section-4.5_error-cases.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts === +class LanguageSpec_section_4_5_error_cases { +>LanguageSpec_section_4_5_error_cases : LanguageSpec_section_4_5_error_cases + + public set AnnotatedSetter_SetterFirst(a: number) { } +>AnnotatedSetter_SetterFirst : number +>a : number + + public get AnnotatedSetter_SetterFirst() { return ""; } +>AnnotatedSetter_SetterFirst : number +>"" : "" + + public get AnnotatedSetter_SetterLast() { return ""; } +>AnnotatedSetter_SetterLast : number +>"" : "" + + public set AnnotatedSetter_SetterLast(a: number) { } +>AnnotatedSetter_SetterLast : number +>a : number + + public get AnnotatedGetter_GetterFirst(): string { return ""; } +>AnnotatedGetter_GetterFirst : string +>"" : "" + + public set AnnotatedGetter_GetterFirst(aStr) { aStr = 0; } +>AnnotatedGetter_GetterFirst : string +>aStr : string +>aStr = 0 : 0 +>aStr : string +>0 : 0 + + public set AnnotatedGetter_GetterLast(aStr) { aStr = 0; } +>AnnotatedGetter_GetterLast : string +>aStr : string +>aStr = 0 : 0 +>aStr : string +>0 : 0 + + public get AnnotatedGetter_GetterLast(): string { return ""; } +>AnnotatedGetter_GetterLast : string +>"" : "" +} diff --git a/tests/baselines/reference/accessors_spec_section-4.5_inference.symbols b/tests/baselines/reference/accessors_spec_section-4.5_inference.symbols new file mode 100644 index 00000000000..de8781c42b0 --- /dev/null +++ b/tests/baselines/reference/accessors_spec_section-4.5_inference.symbols @@ -0,0 +1,64 @@ +=== tests/cases/compiler/accessors_spec_section-4.5_inference.ts === +class A { } +>A : Symbol(A, Decl(accessors_spec_section-4.5_inference.ts, 0, 0)) + +class B extends A { } +>B : Symbol(B, Decl(accessors_spec_section-4.5_inference.ts, 0, 11)) +>A : Symbol(A, Decl(accessors_spec_section-4.5_inference.ts, 0, 0)) + +class LanguageSpec_section_4_5_inference { +>LanguageSpec_section_4_5_inference : Symbol(LanguageSpec_section_4_5_inference, Decl(accessors_spec_section-4.5_inference.ts, 1, 21)) + + public set InferredGetterFromSetterAnnotation(a: A) { } +>InferredGetterFromSetterAnnotation : Symbol(LanguageSpec_section_4_5_inference.InferredGetterFromSetterAnnotation, Decl(accessors_spec_section-4.5_inference.ts, 3, 42), Decl(accessors_spec_section-4.5_inference.ts, 5, 59)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_inference.ts, 5, 50)) +>A : Symbol(A, Decl(accessors_spec_section-4.5_inference.ts, 0, 0)) + + public get InferredGetterFromSetterAnnotation() { return new B(); } +>InferredGetterFromSetterAnnotation : Symbol(LanguageSpec_section_4_5_inference.InferredGetterFromSetterAnnotation, Decl(accessors_spec_section-4.5_inference.ts, 3, 42), Decl(accessors_spec_section-4.5_inference.ts, 5, 59)) +>B : Symbol(B, Decl(accessors_spec_section-4.5_inference.ts, 0, 11)) + + public get InferredGetterFromSetterAnnotation_GetterFirst() { return new B(); } +>InferredGetterFromSetterAnnotation_GetterFirst : Symbol(LanguageSpec_section_4_5_inference.InferredGetterFromSetterAnnotation_GetterFirst, Decl(accessors_spec_section-4.5_inference.ts, 6, 71), Decl(accessors_spec_section-4.5_inference.ts, 8, 83)) +>B : Symbol(B, Decl(accessors_spec_section-4.5_inference.ts, 0, 11)) + + public set InferredGetterFromSetterAnnotation_GetterFirst(a: A) { } +>InferredGetterFromSetterAnnotation_GetterFirst : Symbol(LanguageSpec_section_4_5_inference.InferredGetterFromSetterAnnotation_GetterFirst, Decl(accessors_spec_section-4.5_inference.ts, 6, 71), Decl(accessors_spec_section-4.5_inference.ts, 8, 83)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_inference.ts, 9, 62)) +>A : Symbol(A, Decl(accessors_spec_section-4.5_inference.ts, 0, 0)) + + + public get InferredFromGetter() { return new B(); } +>InferredFromGetter : Symbol(LanguageSpec_section_4_5_inference.InferredFromGetter, Decl(accessors_spec_section-4.5_inference.ts, 9, 71), Decl(accessors_spec_section-4.5_inference.ts, 12, 55)) +>B : Symbol(B, Decl(accessors_spec_section-4.5_inference.ts, 0, 11)) + + public set InferredFromGetter(a) { } +>InferredFromGetter : Symbol(LanguageSpec_section_4_5_inference.InferredFromGetter, Decl(accessors_spec_section-4.5_inference.ts, 9, 71), Decl(accessors_spec_section-4.5_inference.ts, 12, 55)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_inference.ts, 13, 34)) + + public set InferredFromGetter_SetterFirst(a) { } +>InferredFromGetter_SetterFirst : Symbol(LanguageSpec_section_4_5_inference.InferredFromGetter_SetterFirst, Decl(accessors_spec_section-4.5_inference.ts, 13, 40), Decl(accessors_spec_section-4.5_inference.ts, 15, 52)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_inference.ts, 15, 46)) + + public get InferredFromGetter_SetterFirst() { return new B(); } +>InferredFromGetter_SetterFirst : Symbol(LanguageSpec_section_4_5_inference.InferredFromGetter_SetterFirst, Decl(accessors_spec_section-4.5_inference.ts, 13, 40), Decl(accessors_spec_section-4.5_inference.ts, 15, 52)) +>B : Symbol(B, Decl(accessors_spec_section-4.5_inference.ts, 0, 11)) + + public set InferredSetterFromGetterAnnotation(a) { } +>InferredSetterFromGetterAnnotation : Symbol(LanguageSpec_section_4_5_inference.InferredSetterFromGetterAnnotation, Decl(accessors_spec_section-4.5_inference.ts, 16, 67), Decl(accessors_spec_section-4.5_inference.ts, 18, 56)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_inference.ts, 18, 50)) + + public get InferredSetterFromGetterAnnotation() : A { return new B(); } +>InferredSetterFromGetterAnnotation : Symbol(LanguageSpec_section_4_5_inference.InferredSetterFromGetterAnnotation, Decl(accessors_spec_section-4.5_inference.ts, 16, 67), Decl(accessors_spec_section-4.5_inference.ts, 18, 56)) +>A : Symbol(A, Decl(accessors_spec_section-4.5_inference.ts, 0, 0)) +>B : Symbol(B, Decl(accessors_spec_section-4.5_inference.ts, 0, 11)) + + public get InferredSetterFromGetterAnnotation_GetterFirst() : A { return new B(); } +>InferredSetterFromGetterAnnotation_GetterFirst : Symbol(LanguageSpec_section_4_5_inference.InferredSetterFromGetterAnnotation_GetterFirst, Decl(accessors_spec_section-4.5_inference.ts, 19, 75), Decl(accessors_spec_section-4.5_inference.ts, 21, 87)) +>A : Symbol(A, Decl(accessors_spec_section-4.5_inference.ts, 0, 0)) +>B : Symbol(B, Decl(accessors_spec_section-4.5_inference.ts, 0, 11)) + + public set InferredSetterFromGetterAnnotation_GetterFirst(a) { } +>InferredSetterFromGetterAnnotation_GetterFirst : Symbol(LanguageSpec_section_4_5_inference.InferredSetterFromGetterAnnotation_GetterFirst, Decl(accessors_spec_section-4.5_inference.ts, 19, 75), Decl(accessors_spec_section-4.5_inference.ts, 21, 87)) +>a : Symbol(a, Decl(accessors_spec_section-4.5_inference.ts, 22, 62)) +} diff --git a/tests/baselines/reference/accessors_spec_section-4.5_inference.types b/tests/baselines/reference/accessors_spec_section-4.5_inference.types new file mode 100644 index 00000000000..a1d96120634 --- /dev/null +++ b/tests/baselines/reference/accessors_spec_section-4.5_inference.types @@ -0,0 +1,70 @@ +=== tests/cases/compiler/accessors_spec_section-4.5_inference.ts === +class A { } +>A : A + +class B extends A { } +>B : B +>A : A + +class LanguageSpec_section_4_5_inference { +>LanguageSpec_section_4_5_inference : LanguageSpec_section_4_5_inference + + public set InferredGetterFromSetterAnnotation(a: A) { } +>InferredGetterFromSetterAnnotation : A +>a : A +>A : A + + public get InferredGetterFromSetterAnnotation() { return new B(); } +>InferredGetterFromSetterAnnotation : A +>new B() : B +>B : typeof B + + public get InferredGetterFromSetterAnnotation_GetterFirst() { return new B(); } +>InferredGetterFromSetterAnnotation_GetterFirst : A +>new B() : B +>B : typeof B + + public set InferredGetterFromSetterAnnotation_GetterFirst(a: A) { } +>InferredGetterFromSetterAnnotation_GetterFirst : A +>a : A +>A : A + + + public get InferredFromGetter() { return new B(); } +>InferredFromGetter : B +>new B() : B +>B : typeof B + + public set InferredFromGetter(a) { } +>InferredFromGetter : B +>a : B + + public set InferredFromGetter_SetterFirst(a) { } +>InferredFromGetter_SetterFirst : B +>a : B + + public get InferredFromGetter_SetterFirst() { return new B(); } +>InferredFromGetter_SetterFirst : B +>new B() : B +>B : typeof B + + public set InferredSetterFromGetterAnnotation(a) { } +>InferredSetterFromGetterAnnotation : A +>a : A + + public get InferredSetterFromGetterAnnotation() : A { return new B(); } +>InferredSetterFromGetterAnnotation : A +>A : A +>new B() : B +>B : typeof B + + public get InferredSetterFromGetterAnnotation_GetterFirst() : A { return new B(); } +>InferredSetterFromGetterAnnotation_GetterFirst : A +>A : A +>new B() : B +>B : typeof B + + public set InferredSetterFromGetterAnnotation_GetterFirst(a) { } +>InferredSetterFromGetterAnnotation_GetterFirst : A +>a : A +} diff --git a/tests/baselines/reference/addMoreOverloadsToBaseSignature.symbols b/tests/baselines/reference/addMoreOverloadsToBaseSignature.symbols new file mode 100644 index 00000000000..b75df57e2dc --- /dev/null +++ b/tests/baselines/reference/addMoreOverloadsToBaseSignature.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/addMoreOverloadsToBaseSignature.ts === +interface Foo { +>Foo : Symbol(Foo, Decl(addMoreOverloadsToBaseSignature.ts, 0, 0)) + + f(): string; +>f : Symbol(Foo.f, Decl(addMoreOverloadsToBaseSignature.ts, 0, 15)) +} + +interface Bar extends Foo { +>Bar : Symbol(Bar, Decl(addMoreOverloadsToBaseSignature.ts, 2, 1)) +>Foo : Symbol(Foo, Decl(addMoreOverloadsToBaseSignature.ts, 0, 0)) + + f(key: string): string; +>f : Symbol(Bar.f, Decl(addMoreOverloadsToBaseSignature.ts, 4, 27)) +>key : Symbol(key, Decl(addMoreOverloadsToBaseSignature.ts, 5, 6)) +} + diff --git a/tests/baselines/reference/addMoreOverloadsToBaseSignature.types b/tests/baselines/reference/addMoreOverloadsToBaseSignature.types new file mode 100644 index 00000000000..02a566217ad --- /dev/null +++ b/tests/baselines/reference/addMoreOverloadsToBaseSignature.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/addMoreOverloadsToBaseSignature.ts === +interface Foo { +>Foo : Foo + + f(): string; +>f : () => string +} + +interface Bar extends Foo { +>Bar : Bar +>Foo : Foo + + f(key: string): string; +>f : (key: string) => string +>key : string +} + diff --git a/tests/baselines/reference/additionOperatorWithInvalidOperands.symbols b/tests/baselines/reference/additionOperatorWithInvalidOperands.symbols new file mode 100644 index 00000000000..7f734550635 --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithInvalidOperands.symbols @@ -0,0 +1,142 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts === +function foo() { } +>foo : Symbol(foo, Decl(additionOperatorWithInvalidOperands.ts, 0, 0)) + +class C { +>C : Symbol(C, Decl(additionOperatorWithInvalidOperands.ts, 0, 18)) + + public a: string; +>a : Symbol(C.a, Decl(additionOperatorWithInvalidOperands.ts, 1, 9)) + + static foo() { } +>foo : Symbol(C.foo, Decl(additionOperatorWithInvalidOperands.ts, 2, 21)) +} +enum E { a, b, c } +>E : Symbol(E, Decl(additionOperatorWithInvalidOperands.ts, 4, 1)) +>a : Symbol(E.a, Decl(additionOperatorWithInvalidOperands.ts, 5, 8)) +>b : Symbol(E.b, Decl(additionOperatorWithInvalidOperands.ts, 5, 11)) +>c : Symbol(E.c, Decl(additionOperatorWithInvalidOperands.ts, 5, 14)) + +module M { export var a } +>M : Symbol(M, Decl(additionOperatorWithInvalidOperands.ts, 5, 18)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 6, 21)) + +var a: boolean; +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) + +var b: number; +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) + +var c: Object; +>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var d: Number; +>d : Symbol(d, Decl(additionOperatorWithInvalidOperands.ts, 11, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +// boolean + every type except any and string +var r1 = a + a; +>r1 : Symbol(r1, Decl(additionOperatorWithInvalidOperands.ts, 14, 3)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) + +var r2 = a + b; +>r2 : Symbol(r2, Decl(additionOperatorWithInvalidOperands.ts, 15, 3)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) + +var r3 = a + c; +>r3 : Symbol(r3, Decl(additionOperatorWithInvalidOperands.ts, 16, 3)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3)) + +// number + every type except any and string +var r4 = b + a; +>r4 : Symbol(r4, Decl(additionOperatorWithInvalidOperands.ts, 19, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) + +var r5 = b + b; // number + number is valid +>r5 : Symbol(r5, Decl(additionOperatorWithInvalidOperands.ts, 20, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) + +var r6 = b + c; +>r6 : Symbol(r6, Decl(additionOperatorWithInvalidOperands.ts, 21, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3)) + +// object + every type except any and string +var r7 = c + a; +>r7 : Symbol(r7, Decl(additionOperatorWithInvalidOperands.ts, 24, 3)) +>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) + +var r8 = c + b; +>r8 : Symbol(r8, Decl(additionOperatorWithInvalidOperands.ts, 25, 3)) +>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) + +var r9 = c + c; +>r9 : Symbol(r9, Decl(additionOperatorWithInvalidOperands.ts, 26, 3)) +>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3)) +>c : Symbol(c, Decl(additionOperatorWithInvalidOperands.ts, 10, 3)) + +// other cases +var r10 = a + true; +>r10 : Symbol(r10, Decl(additionOperatorWithInvalidOperands.ts, 29, 3)) +>a : Symbol(a, Decl(additionOperatorWithInvalidOperands.ts, 8, 3)) + +var r11 = true + false; +>r11 : Symbol(r11, Decl(additionOperatorWithInvalidOperands.ts, 30, 3)) + +var r12 = true + 123; +>r12 : Symbol(r12, Decl(additionOperatorWithInvalidOperands.ts, 31, 3)) + +var r13 = {} + {}; +>r13 : Symbol(r13, Decl(additionOperatorWithInvalidOperands.ts, 32, 3)) + +var r14 = b + d; +>r14 : Symbol(r14, Decl(additionOperatorWithInvalidOperands.ts, 33, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(additionOperatorWithInvalidOperands.ts, 11, 3)) + +var r15 = b + foo; +>r15 : Symbol(r15, Decl(additionOperatorWithInvalidOperands.ts, 34, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) +>foo : Symbol(foo, Decl(additionOperatorWithInvalidOperands.ts, 0, 0)) + +var r16 = b + foo(); +>r16 : Symbol(r16, Decl(additionOperatorWithInvalidOperands.ts, 35, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) +>foo : Symbol(foo, Decl(additionOperatorWithInvalidOperands.ts, 0, 0)) + +var r17 = b + C; +>r17 : Symbol(r17, Decl(additionOperatorWithInvalidOperands.ts, 36, 3)) +>b : Symbol(b, Decl(additionOperatorWithInvalidOperands.ts, 9, 3)) +>C : Symbol(C, Decl(additionOperatorWithInvalidOperands.ts, 0, 18)) + +var r18 = E.a + new C(); +>r18 : Symbol(r18, Decl(additionOperatorWithInvalidOperands.ts, 37, 3)) +>E.a : Symbol(E.a, Decl(additionOperatorWithInvalidOperands.ts, 5, 8)) +>E : Symbol(E, Decl(additionOperatorWithInvalidOperands.ts, 4, 1)) +>a : Symbol(E.a, Decl(additionOperatorWithInvalidOperands.ts, 5, 8)) +>C : Symbol(C, Decl(additionOperatorWithInvalidOperands.ts, 0, 18)) + +var r19 = E.a + C.foo(); +>r19 : Symbol(r19, Decl(additionOperatorWithInvalidOperands.ts, 38, 3)) +>E.a : Symbol(E.a, Decl(additionOperatorWithInvalidOperands.ts, 5, 8)) +>E : Symbol(E, Decl(additionOperatorWithInvalidOperands.ts, 4, 1)) +>a : Symbol(E.a, Decl(additionOperatorWithInvalidOperands.ts, 5, 8)) +>C.foo : Symbol(C.foo, Decl(additionOperatorWithInvalidOperands.ts, 2, 21)) +>C : Symbol(C, Decl(additionOperatorWithInvalidOperands.ts, 0, 18)) +>foo : Symbol(C.foo, Decl(additionOperatorWithInvalidOperands.ts, 2, 21)) + +var r20 = E.a + M; +>r20 : Symbol(r20, Decl(additionOperatorWithInvalidOperands.ts, 39, 3)) +>E.a : Symbol(E.a, Decl(additionOperatorWithInvalidOperands.ts, 5, 8)) +>E : Symbol(E, Decl(additionOperatorWithInvalidOperands.ts, 4, 1)) +>a : Symbol(E.a, Decl(additionOperatorWithInvalidOperands.ts, 5, 8)) +>M : Symbol(M, Decl(additionOperatorWithInvalidOperands.ts, 5, 18)) + diff --git a/tests/baselines/reference/additionOperatorWithInvalidOperands.types b/tests/baselines/reference/additionOperatorWithInvalidOperands.types new file mode 100644 index 00000000000..9701d8552dd --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithInvalidOperands.types @@ -0,0 +1,172 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts === +function foo() { } +>foo : () => void + +class C { +>C : C + + public a: string; +>a : string + + static foo() { } +>foo : () => void +} +enum E { a, b, c } +>E : E +>a : E.a +>b : E.b +>c : E.c + +module M { export var a } +>M : typeof M +>a : any + +var a: boolean; +>a : boolean + +var b: number; +>b : number + +var c: Object; +>c : Object +>Object : Object + +var d: Number; +>d : Number +>Number : Number + +// boolean + every type except any and string +var r1 = a + a; +>r1 : any +>a + a : any +>a : boolean +>a : boolean + +var r2 = a + b; +>r2 : any +>a + b : any +>a : boolean +>b : number + +var r3 = a + c; +>r3 : any +>a + c : any +>a : boolean +>c : Object + +// number + every type except any and string +var r4 = b + a; +>r4 : any +>b + a : any +>b : number +>a : boolean + +var r5 = b + b; // number + number is valid +>r5 : number +>b + b : number +>b : number +>b : number + +var r6 = b + c; +>r6 : any +>b + c : any +>b : number +>c : Object + +// object + every type except any and string +var r7 = c + a; +>r7 : any +>c + a : any +>c : Object +>a : boolean + +var r8 = c + b; +>r8 : any +>c + b : any +>c : Object +>b : number + +var r9 = c + c; +>r9 : any +>c + c : any +>c : Object +>c : Object + +// other cases +var r10 = a + true; +>r10 : any +>a + true : any +>a : boolean +>true : true + +var r11 = true + false; +>r11 : any +>true + false : any +>true : true +>false : false + +var r12 = true + 123; +>r12 : any +>true + 123 : any +>true : true +>123 : 123 + +var r13 = {} + {}; +>r13 : any +>{} + {} : any +>{} : {} +>{} : {} + +var r14 = b + d; +>r14 : any +>b + d : any +>b : number +>d : Number + +var r15 = b + foo; +>r15 : any +>b + foo : any +>b : number +>foo : () => void + +var r16 = b + foo(); +>r16 : any +>b + foo() : any +>b : number +>foo() : void +>foo : () => void + +var r17 = b + C; +>r17 : any +>b + C : any +>b : number +>C : typeof C + +var r18 = E.a + new C(); +>r18 : any +>E.a + new C() : any +>E.a : E.a +>E : typeof E +>a : E.a +>new C() : C +>C : typeof C + +var r19 = E.a + C.foo(); +>r19 : any +>E.a + C.foo() : any +>E.a : E.a +>E : typeof E +>a : E.a +>C.foo() : void +>C.foo : () => void +>C : typeof C +>foo : () => void + +var r20 = E.a + M; +>r20 : any +>E.a + M : any +>E.a : E.a +>E : typeof E +>a : E.a +>M : typeof M + diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols new file mode 100644 index 00000000000..5ee9952329e --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.symbols @@ -0,0 +1,65 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts === +// If one operand is the null or undefined value, it is treated as having the type of the other operand. + +function foo(): void { return undefined } +>foo : Symbol(foo, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 0, 0)) +>undefined : Symbol(undefined) + +var a: boolean; +>a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 3)) + +var b: Object; +>b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var c: void; +>c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 3)) + +var d: Number; +>d : Symbol(d, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 7, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +// null + boolean/Object +var r1 = null + a; +>r1 : Symbol(r1, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 10, 3)) +>a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 3)) + +var r2 = null + b; +>r2 : Symbol(r2, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 11, 3)) +>b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 3)) + +var r3 = null + c; +>r3 : Symbol(r3, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 12, 3)) +>c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 3)) + +var r4 = a + null; +>r4 : Symbol(r4, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 13, 3)) +>a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 4, 3)) + +var r5 = b + null; +>r5 : Symbol(r5, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 14, 3)) +>b : Symbol(b, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 5, 3)) + +var r6 = null + c; +>r6 : Symbol(r6, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 15, 3)) +>c : Symbol(c, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 6, 3)) + +// other cases +var r7 = null + d; +>r7 : Symbol(r7, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 18, 3)) +>d : Symbol(d, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 7, 3)) + +var r8 = null + true; +>r8 : Symbol(r8, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 19, 3)) + +var r9 = null + { a: '' }; +>r9 : Symbol(r9, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 20, 3)) +>a : Symbol(a, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 20, 17)) + +var r10 = null + foo(); +>r10 : Symbol(r10, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 21, 3)) +>foo : Symbol(foo, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 0, 0)) + +var r11 = null + (() => { }); +>r11 : Symbol(r11, Decl(additionOperatorWithNullValueAndInvalidOperator.ts, 22, 3)) + diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types new file mode 100644 index 00000000000..7e0d5d7ab31 --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.types @@ -0,0 +1,93 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts === +// If one operand is the null or undefined value, it is treated as having the type of the other operand. + +function foo(): void { return undefined } +>foo : () => void +>undefined : undefined + +var a: boolean; +>a : boolean + +var b: Object; +>b : Object +>Object : Object + +var c: void; +>c : void + +var d: Number; +>d : Number +>Number : Number + +// null + boolean/Object +var r1 = null + a; +>r1 : any +>null + a : any +>null : null +>a : boolean + +var r2 = null + b; +>r2 : any +>null + b : any +>null : null +>b : Object + +var r3 = null + c; +>r3 : any +>null + c : any +>null : null +>c : void + +var r4 = a + null; +>r4 : any +>a + null : any +>a : boolean +>null : null + +var r5 = b + null; +>r5 : any +>b + null : any +>b : Object +>null : null + +var r6 = null + c; +>r6 : any +>null + c : any +>null : null +>c : void + +// other cases +var r7 = null + d; +>r7 : any +>null + d : any +>null : null +>d : Number + +var r8 = null + true; +>r8 : any +>null + true : any +>null : null +>true : true + +var r9 = null + { a: '' }; +>r9 : any +>null + { a: '' } : any +>null : null +>{ a: '' } : { a: string; } +>a : string +>'' : "" + +var r10 = null + foo(); +>r10 : any +>null + foo() : any +>null : null +>foo() : void +>foo : () => void + +var r11 = null + (() => { }); +>r11 : any +>null + (() => { }) : any +>null : null +>(() => { }) : () => void +>() => { } : () => void + diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types index d0feec523b0..e6c8e919de2 100644 --- a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types +++ b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types @@ -35,68 +35,68 @@ var r2: any = a + null; // null + number/enum var r3 = null + b; ->r3 : number ->null + b : number +>r3 : any +>null + b : any >null : null >b : number var r4 = null + 1; ->r4 : number ->null + 1 : number +>r4 : any +>null + 1 : any >null : null >1 : 1 var r5 = null + c; ->r5 : number ->null + c : number +>r5 : any +>null + c : any >null : null >c : E var r6 = null + E.a; ->r6 : number ->null + E.a : number +>r6 : any +>null + E.a : any >null : null >E.a : E.a >E : typeof E >a : E.a var r7 = null + E['a']; ->r7 : number ->null + E['a'] : number +>r7 : any +>null + E['a'] : any >null : null >E['a'] : E.a >E : typeof E >'a' : "a" var r8 = b + null; ->r8 : number ->b + null : number +>r8 : any +>b + null : any >b : number >null : null var r9 = 1 + null; ->r9 : number ->1 + null : number +>r9 : any +>1 + null : any >1 : 1 >null : null var r10 = c + null ->r10 : number ->c + null : number +>r10 : any +>c + null : any >c : E >null : null var r11 = E.a + null; ->r11 : number ->E.a + null : number +>r11 : any +>E.a + null : any >E.a : E.a >E : typeof E >a : E.a >null : null var r12 = E['a'] + null; ->r12 : number ->E['a'] + null : number +>r12 : any +>E['a'] + null : any >E['a'] : E.a >E : typeof E >'a' : "a" diff --git a/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.symbols b/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.symbols new file mode 100644 index 00000000000..87ae4f5578d --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts === +// bug 819721 +var r1 = null + null; +>r1 : Symbol(r1, Decl(additionOperatorWithOnlyNullValueOrUndefinedValue.ts, 1, 3)) + +var r2 = null + undefined; +>r2 : Symbol(r2, Decl(additionOperatorWithOnlyNullValueOrUndefinedValue.ts, 2, 3)) +>undefined : Symbol(undefined) + +var r3 = undefined + null; +>r3 : Symbol(r3, Decl(additionOperatorWithOnlyNullValueOrUndefinedValue.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r4 = undefined + undefined; +>r4 : Symbol(r4, Decl(additionOperatorWithOnlyNullValueOrUndefinedValue.ts, 4, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + diff --git a/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.types b/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.types new file mode 100644 index 00000000000..b0b4955a846 --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithOnlyNullValueOrUndefinedValue.types @@ -0,0 +1,26 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithOnlyNullValueOrUndefinedValue.ts === +// bug 819721 +var r1 = null + null; +>r1 : any +>null + null : any +>null : null +>null : null + +var r2 = null + undefined; +>r2 : any +>null + undefined : any +>null : null +>undefined : undefined + +var r3 = undefined + null; +>r3 : any +>undefined + null : any +>undefined : undefined +>null : null + +var r4 = undefined + undefined; +>r4 : any +>undefined + undefined : any +>undefined : undefined +>undefined : undefined + diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.symbols b/tests/baselines/reference/additionOperatorWithTypeParameter.symbols new file mode 100644 index 00000000000..586b85195b6 --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithTypeParameter.symbols @@ -0,0 +1,139 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts === +// type parameter type is not a valid operand of addition operator +enum E { a, b } +>E : Symbol(E, Decl(additionOperatorWithTypeParameter.ts, 0, 0)) +>a : Symbol(E.a, Decl(additionOperatorWithTypeParameter.ts, 1, 8)) +>b : Symbol(E.b, Decl(additionOperatorWithTypeParameter.ts, 1, 11)) + +function foo(t: T, u: U) { +>foo : Symbol(foo, Decl(additionOperatorWithTypeParameter.ts, 1, 15)) +>T : Symbol(T, Decl(additionOperatorWithTypeParameter.ts, 3, 13)) +>U : Symbol(U, Decl(additionOperatorWithTypeParameter.ts, 3, 15)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>T : Symbol(T, Decl(additionOperatorWithTypeParameter.ts, 3, 13)) +>u : Symbol(u, Decl(additionOperatorWithTypeParameter.ts, 3, 24)) +>U : Symbol(U, Decl(additionOperatorWithTypeParameter.ts, 3, 15)) + + var a: any; +>a : Symbol(a, Decl(additionOperatorWithTypeParameter.ts, 4, 7)) + + var b: boolean; +>b : Symbol(b, Decl(additionOperatorWithTypeParameter.ts, 5, 7)) + + var c: number; +>c : Symbol(c, Decl(additionOperatorWithTypeParameter.ts, 6, 7)) + + var d: string; +>d : Symbol(d, Decl(additionOperatorWithTypeParameter.ts, 7, 7)) + + var e: Object; +>e : Symbol(e, Decl(additionOperatorWithTypeParameter.ts, 8, 7)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + var g: E; +>g : Symbol(g, Decl(additionOperatorWithTypeParameter.ts, 9, 7)) +>E : Symbol(E, Decl(additionOperatorWithTypeParameter.ts, 0, 0)) + + var f: void; +>f : Symbol(f, Decl(additionOperatorWithTypeParameter.ts, 10, 7)) + + // type parameter as left operand + var r1: any = t + a; // ok, one operand is any +>r1 : Symbol(r1, Decl(additionOperatorWithTypeParameter.ts, 13, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>a : Symbol(a, Decl(additionOperatorWithTypeParameter.ts, 4, 7)) + + var r2 = t + b; +>r2 : Symbol(r2, Decl(additionOperatorWithTypeParameter.ts, 14, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>b : Symbol(b, Decl(additionOperatorWithTypeParameter.ts, 5, 7)) + + var r3 = t + c; +>r3 : Symbol(r3, Decl(additionOperatorWithTypeParameter.ts, 15, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>c : Symbol(c, Decl(additionOperatorWithTypeParameter.ts, 6, 7)) + + var r4 = t + d; // ok, one operand is string +>r4 : Symbol(r4, Decl(additionOperatorWithTypeParameter.ts, 16, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>d : Symbol(d, Decl(additionOperatorWithTypeParameter.ts, 7, 7)) + + var r5 = t + e; +>r5 : Symbol(r5, Decl(additionOperatorWithTypeParameter.ts, 17, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>e : Symbol(e, Decl(additionOperatorWithTypeParameter.ts, 8, 7)) + + var r6 = t + g; +>r6 : Symbol(r6, Decl(additionOperatorWithTypeParameter.ts, 18, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>g : Symbol(g, Decl(additionOperatorWithTypeParameter.ts, 9, 7)) + + var r7 = t + f; +>r7 : Symbol(r7, Decl(additionOperatorWithTypeParameter.ts, 19, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>f : Symbol(f, Decl(additionOperatorWithTypeParameter.ts, 10, 7)) + + // type parameter as right operand + var r8 = a + t; // ok, one operand is any +>r8 : Symbol(r8, Decl(additionOperatorWithTypeParameter.ts, 22, 7)) +>a : Symbol(a, Decl(additionOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r9 = b + t; +>r9 : Symbol(r9, Decl(additionOperatorWithTypeParameter.ts, 23, 7)) +>b : Symbol(b, Decl(additionOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r10 = c + t; +>r10 : Symbol(r10, Decl(additionOperatorWithTypeParameter.ts, 24, 7)) +>c : Symbol(c, Decl(additionOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r11 = d + t; // ok, one operand is string +>r11 : Symbol(r11, Decl(additionOperatorWithTypeParameter.ts, 25, 7)) +>d : Symbol(d, Decl(additionOperatorWithTypeParameter.ts, 7, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r12 = e + t; +>r12 : Symbol(r12, Decl(additionOperatorWithTypeParameter.ts, 26, 7)) +>e : Symbol(e, Decl(additionOperatorWithTypeParameter.ts, 8, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r13 = g + t; +>r13 : Symbol(r13, Decl(additionOperatorWithTypeParameter.ts, 27, 7)) +>g : Symbol(g, Decl(additionOperatorWithTypeParameter.ts, 9, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r14 = f + t; +>r14 : Symbol(r14, Decl(additionOperatorWithTypeParameter.ts, 28, 7)) +>f : Symbol(f, Decl(additionOperatorWithTypeParameter.ts, 10, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + // other cases + var r15 = t + null; +>r15 : Symbol(r15, Decl(additionOperatorWithTypeParameter.ts, 31, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r16 = t + undefined; +>r16 : Symbol(r16, Decl(additionOperatorWithTypeParameter.ts, 32, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>undefined : Symbol(undefined) + + var r17 = t + t; +>r17 : Symbol(r17, Decl(additionOperatorWithTypeParameter.ts, 33, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r18 = t + u; +>r18 : Symbol(r18, Decl(additionOperatorWithTypeParameter.ts, 34, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +>u : Symbol(u, Decl(additionOperatorWithTypeParameter.ts, 3, 24)) + + var r19 = t + (() => { }); +>r19 : Symbol(r19, Decl(additionOperatorWithTypeParameter.ts, 35, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) + + var r20 = t + []; +>r20 : Symbol(r20, Decl(additionOperatorWithTypeParameter.ts, 36, 7)) +>t : Symbol(t, Decl(additionOperatorWithTypeParameter.ts, 3, 19)) +} diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.types b/tests/baselines/reference/additionOperatorWithTypeParameter.types new file mode 100644 index 00000000000..1ebc2d5b02f --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithTypeParameter.types @@ -0,0 +1,163 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithTypeParameter.ts === +// type parameter type is not a valid operand of addition operator +enum E { a, b } +>E : E +>a : E.a +>b : E.b + +function foo(t: T, u: U) { +>foo : (t: T, u: U) => void +>T : T +>U : U +>t : T +>T : T +>u : U +>U : U + + var a: any; +>a : any + + var b: boolean; +>b : boolean + + var c: number; +>c : number + + var d: string; +>d : string + + var e: Object; +>e : Object +>Object : Object + + var g: E; +>g : E +>E : E + + var f: void; +>f : void + + // type parameter as left operand + var r1: any = t + a; // ok, one operand is any +>r1 : any +>t + a : any +>t : T +>a : any + + var r2 = t + b; +>r2 : any +>t + b : any +>t : T +>b : boolean + + var r3 = t + c; +>r3 : any +>t + c : any +>t : T +>c : number + + var r4 = t + d; // ok, one operand is string +>r4 : string +>t + d : string +>t : T +>d : string + + var r5 = t + e; +>r5 : any +>t + e : any +>t : T +>e : Object + + var r6 = t + g; +>r6 : any +>t + g : any +>t : T +>g : E + + var r7 = t + f; +>r7 : any +>t + f : any +>t : T +>f : void + + // type parameter as right operand + var r8 = a + t; // ok, one operand is any +>r8 : any +>a + t : any +>a : any +>t : T + + var r9 = b + t; +>r9 : any +>b + t : any +>b : boolean +>t : T + + var r10 = c + t; +>r10 : any +>c + t : any +>c : number +>t : T + + var r11 = d + t; // ok, one operand is string +>r11 : string +>d + t : string +>d : string +>t : T + + var r12 = e + t; +>r12 : any +>e + t : any +>e : Object +>t : T + + var r13 = g + t; +>r13 : any +>g + t : any +>g : E +>t : T + + var r14 = f + t; +>r14 : any +>f + t : any +>f : void +>t : T + + // other cases + var r15 = t + null; +>r15 : any +>t + null : any +>t : T +>null : null + + var r16 = t + undefined; +>r16 : any +>t + undefined : any +>t : T +>undefined : undefined + + var r17 = t + t; +>r17 : any +>t + t : any +>t : T +>t : T + + var r18 = t + u; +>r18 : any +>t + u : any +>t : T +>u : U + + var r19 = t + (() => { }); +>r19 : any +>t + (() => { }) : any +>t : T +>(() => { }) : () => void +>() => { } : () => void + + var r20 = t + []; +>r20 : any +>t + [] : any +>t : T +>[] : undefined[] +} diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols new file mode 100644 index 00000000000..eac61496e1a --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.symbols @@ -0,0 +1,76 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts === +// If one operand is the null or undefined value, it is treated as having the type of the other operand. + +function foo(): void { return undefined } +>foo : Symbol(foo, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 0, 0)) +>undefined : Symbol(undefined) + +var a: boolean; +>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var b: Object; +>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var c: void; +>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 3)) + +var d: Number; +>d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 7, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +// undefined + boolean/Object +var r1 = undefined + a; +>r1 : Symbol(r1, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 10, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r2 = undefined + b; +>r2 : Symbol(r2, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 11, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r3 = undefined + c; +>r3 : Symbol(r3, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 12, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 3)) + +var r4 = a + undefined; +>r4 : Symbol(r4, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 13, 3)) +>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r5 = b + undefined; +>r5 : Symbol(r5, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 14, 3)) +>b : Symbol(b, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r6 = undefined + c; +>r6 : Symbol(r6, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 15, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 6, 3)) + +// other cases +var r7 = undefined + d; +>r7 : Symbol(r7, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 18, 3)) +>undefined : Symbol(undefined) +>d : Symbol(d, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 7, 3)) + +var r8 = undefined + true; +>r8 : Symbol(r8, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 19, 3)) +>undefined : Symbol(undefined) + +var r9 = undefined + { a: '' }; +>r9 : Symbol(r9, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 20, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 20, 22)) + +var r10 = undefined + foo(); +>r10 : Symbol(r10, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 21, 3)) +>undefined : Symbol(undefined) +>foo : Symbol(foo, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 0, 0)) + +var r11 = undefined + (() => { }); +>r11 : Symbol(r11, Decl(additionOperatorWithUndefinedValueAndInvalidOperands.ts, 22, 3)) +>undefined : Symbol(undefined) + diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types new file mode 100644 index 00000000000..4a38511c10e --- /dev/null +++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.types @@ -0,0 +1,93 @@ +=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts === +// If one operand is the null or undefined value, it is treated as having the type of the other operand. + +function foo(): void { return undefined } +>foo : () => void +>undefined : undefined + +var a: boolean; +>a : boolean + +var b: Object; +>b : Object +>Object : Object + +var c: void; +>c : void + +var d: Number; +>d : Number +>Number : Number + +// undefined + boolean/Object +var r1 = undefined + a; +>r1 : any +>undefined + a : any +>undefined : undefined +>a : boolean + +var r2 = undefined + b; +>r2 : any +>undefined + b : any +>undefined : undefined +>b : Object + +var r3 = undefined + c; +>r3 : any +>undefined + c : any +>undefined : undefined +>c : void + +var r4 = a + undefined; +>r4 : any +>a + undefined : any +>a : boolean +>undefined : undefined + +var r5 = b + undefined; +>r5 : any +>b + undefined : any +>b : Object +>undefined : undefined + +var r6 = undefined + c; +>r6 : any +>undefined + c : any +>undefined : undefined +>c : void + +// other cases +var r7 = undefined + d; +>r7 : any +>undefined + d : any +>undefined : undefined +>d : Number + +var r8 = undefined + true; +>r8 : any +>undefined + true : any +>undefined : undefined +>true : true + +var r9 = undefined + { a: '' }; +>r9 : any +>undefined + { a: '' } : any +>undefined : undefined +>{ a: '' } : { a: string; } +>a : string +>'' : "" + +var r10 = undefined + foo(); +>r10 : any +>undefined + foo() : any +>undefined : undefined +>foo() : void +>foo : () => void + +var r11 = undefined + (() => { }); +>r11 : any +>undefined + (() => { }) : any +>undefined : undefined +>(() => { }) : () => void +>() => { } : () => void + diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types index 46ba3a147e6..2d0177c1675 100644 --- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types +++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types @@ -35,68 +35,68 @@ var r2: any = a + undefined; // undefined + number/enum var r3 = undefined + b; ->r3 : number ->undefined + b : number +>r3 : any +>undefined + b : any >undefined : undefined >b : number var r4 = undefined + 1; ->r4 : number ->undefined + 1 : number +>r4 : any +>undefined + 1 : any >undefined : undefined >1 : 1 var r5 = undefined + c; ->r5 : number ->undefined + c : number +>r5 : any +>undefined + c : any >undefined : undefined >c : E var r6 = undefined + E.a; ->r6 : number ->undefined + E.a : number +>r6 : any +>undefined + E.a : any >undefined : undefined >E.a : E.a >E : typeof E >a : E.a var r7 = undefined + E['a']; ->r7 : number ->undefined + E['a'] : number +>r7 : any +>undefined + E['a'] : any >undefined : undefined >E['a'] : E.a >E : typeof E >'a' : "a" var r8 = b + undefined; ->r8 : number ->b + undefined : number +>r8 : any +>b + undefined : any >b : number >undefined : undefined var r9 = 1 + undefined; ->r9 : number ->1 + undefined : number +>r9 : any +>1 + undefined : any >1 : 1 >undefined : undefined var r10 = c + undefined ->r10 : number ->c + undefined : number +>r10 : any +>c + undefined : any >c : E >undefined : undefined var r11 = E.a + undefined; ->r11 : number ->E.a + undefined : number +>r11 : any +>E.a + undefined : any >E.a : E.a >E : typeof E >a : E.a >undefined : undefined var r12 = E['a'] + undefined; ->r12 : number ->E['a'] + undefined : number +>r12 : any +>E['a'] + undefined : any >E['a'] : E.a >E : typeof E >'a' : "a" diff --git a/tests/baselines/reference/aliasAssignments.symbols b/tests/baselines/reference/aliasAssignments.symbols new file mode 100644 index 00000000000..e5d9594c847 --- /dev/null +++ b/tests/baselines/reference/aliasAssignments.symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/aliasAssignments_1.ts === +import moduleA = require("./aliasAssignments_moduleA"); +>moduleA : Symbol(moduleA, Decl(aliasAssignments_1.ts, 0, 0)) + +var x = moduleA; +>x : Symbol(x, Decl(aliasAssignments_1.ts, 1, 3)) +>moduleA : Symbol(moduleA, Decl(aliasAssignments_1.ts, 0, 0)) + +x = 1; // Should be error +>x : Symbol(x, Decl(aliasAssignments_1.ts, 1, 3)) + +var y = 1; +>y : Symbol(y, Decl(aliasAssignments_1.ts, 3, 3)) + +y = moduleA; // should be error +>y : Symbol(y, Decl(aliasAssignments_1.ts, 3, 3)) +>moduleA : Symbol(moduleA, Decl(aliasAssignments_1.ts, 0, 0)) + +=== tests/cases/compiler/aliasAssignments_moduleA.ts === +export class someClass { +>someClass : Symbol(someClass, Decl(aliasAssignments_moduleA.ts, 0, 0)) + + public someData: string; +>someData : Symbol(someClass.someData, Decl(aliasAssignments_moduleA.ts, 0, 24)) +} + diff --git a/tests/baselines/reference/aliasAssignments.types b/tests/baselines/reference/aliasAssignments.types new file mode 100644 index 00000000000..efb36541a48 --- /dev/null +++ b/tests/baselines/reference/aliasAssignments.types @@ -0,0 +1,30 @@ +=== tests/cases/compiler/aliasAssignments_1.ts === +import moduleA = require("./aliasAssignments_moduleA"); +>moduleA : typeof moduleA + +var x = moduleA; +>x : typeof moduleA +>moduleA : typeof moduleA + +x = 1; // Should be error +>x = 1 : 1 +>x : typeof moduleA +>1 : 1 + +var y = 1; +>y : number +>1 : 1 + +y = moduleA; // should be error +>y = moduleA : typeof moduleA +>y : number +>moduleA : typeof moduleA + +=== tests/cases/compiler/aliasAssignments_moduleA.ts === +export class someClass { +>someClass : someClass + + public someData: string; +>someData : string +} + diff --git a/tests/baselines/reference/aliasBug.symbols b/tests/baselines/reference/aliasBug.symbols new file mode 100644 index 00000000000..8dae267b5be --- /dev/null +++ b/tests/baselines/reference/aliasBug.symbols @@ -0,0 +1,54 @@ +=== tests/cases/compiler/aliasBug.ts === +module foo { +>foo : Symbol(foo, Decl(aliasBug.ts, 0, 0)) + + export class Provide { +>Provide : Symbol(Provide, Decl(aliasBug.ts, 0, 12)) + } + + export module bar { export module baz {export class boo {}}} +>bar : Symbol(bar, Decl(aliasBug.ts, 2, 5)) +>baz : Symbol(baz, Decl(aliasBug.ts, 4, 23)) +>boo : Symbol(boo, Decl(aliasBug.ts, 4, 43)) +} + +import provide = foo; +>provide : Symbol(provide, Decl(aliasBug.ts, 5, 1)) +>foo : Symbol(foo, Decl(aliasBug.ts, 0, 0)) + +import booz = foo.bar.baz; +>booz : Symbol(booz, Decl(aliasBug.ts, 7, 21)) +>foo : Symbol(foo, Decl(aliasBug.ts, 0, 0)) +>bar : Symbol(provide.bar, Decl(aliasBug.ts, 2, 5)) +>baz : Symbol(booz, Decl(aliasBug.ts, 4, 23)) + +var p = new provide.Provide(); +>p : Symbol(p, Decl(aliasBug.ts, 10, 3)) +>provide.Provide : Symbol(provide.Provide, Decl(aliasBug.ts, 0, 12)) +>provide : Symbol(provide, Decl(aliasBug.ts, 5, 1)) +>Provide : Symbol(provide.Provide, Decl(aliasBug.ts, 0, 12)) + +function use() { +>use : Symbol(use, Decl(aliasBug.ts, 10, 30)) + + var p1: provide.Provide; // error here, but should be okay +>p1 : Symbol(p1, Decl(aliasBug.ts, 13, 5)) +>provide : Symbol(provide, Decl(aliasBug.ts, 5, 1)) +>Provide : Symbol(provide.Provide, Decl(aliasBug.ts, 0, 12)) + + var p2: foo.Provide; +>p2 : Symbol(p2, Decl(aliasBug.ts, 14, 5)) +>foo : Symbol(foo, Decl(aliasBug.ts, 0, 0)) +>Provide : Symbol(provide.Provide, Decl(aliasBug.ts, 0, 12)) + + var p3:booz.bar; +>p3 : Symbol(p3, Decl(aliasBug.ts, 15, 5)) +>booz : Symbol(booz, Decl(aliasBug.ts, 7, 21)) + + var p22 = new provide.Provide(); +>p22 : Symbol(p22, Decl(aliasBug.ts, 16, 5)) +>provide.Provide : Symbol(provide.Provide, Decl(aliasBug.ts, 0, 12)) +>provide : Symbol(provide, Decl(aliasBug.ts, 5, 1)) +>Provide : Symbol(provide.Provide, Decl(aliasBug.ts, 0, 12)) +} + diff --git a/tests/baselines/reference/aliasBug.types b/tests/baselines/reference/aliasBug.types new file mode 100644 index 00000000000..6a896a64c29 --- /dev/null +++ b/tests/baselines/reference/aliasBug.types @@ -0,0 +1,57 @@ +=== tests/cases/compiler/aliasBug.ts === +module foo { +>foo : typeof foo + + export class Provide { +>Provide : Provide + } + + export module bar { export module baz {export class boo {}}} +>bar : typeof bar +>baz : typeof baz +>boo : boo +} + +import provide = foo; +>provide : typeof foo +>foo : typeof foo + +import booz = foo.bar.baz; +>booz : typeof booz +>foo : typeof foo +>bar : typeof provide.bar +>baz : typeof booz + +var p = new provide.Provide(); +>p : provide.Provide +>new provide.Provide() : provide.Provide +>provide.Provide : typeof provide.Provide +>provide : typeof foo +>Provide : typeof provide.Provide + +function use() { +>use : () => void + + var p1: provide.Provide; // error here, but should be okay +>p1 : provide.Provide +>provide : any +>Provide : provide.Provide + + var p2: foo.Provide; +>p2 : provide.Provide +>foo : any +>Provide : provide.Provide + + var p3:booz.bar; +>p3 : any +>booz : any +>bar : No type information available! + + var p22 = new provide.Provide(); +>p22 : provide.Provide +>new provide.Provide() : provide.Provide +>provide.Provide : typeof provide.Provide +>provide : typeof foo +>Provide : typeof provide.Provide +} + diff --git a/tests/baselines/reference/aliasErrors.symbols b/tests/baselines/reference/aliasErrors.symbols new file mode 100644 index 00000000000..2a0e5b58256 --- /dev/null +++ b/tests/baselines/reference/aliasErrors.symbols @@ -0,0 +1,85 @@ +=== tests/cases/compiler/aliasErrors.ts === +module foo { +>foo : Symbol(foo, Decl(aliasErrors.ts, 0, 0)) + + export class Provide { +>Provide : Symbol(Provide, Decl(aliasErrors.ts, 0, 12)) + } + export module bar { export module baz {export class boo {}}} +>bar : Symbol(bar, Decl(aliasErrors.ts, 2, 5)) +>baz : Symbol(baz, Decl(aliasErrors.ts, 3, 23)) +>boo : Symbol(boo, Decl(aliasErrors.ts, 3, 43)) +} + +import provide = foo; +>provide : Symbol(provide, Decl(aliasErrors.ts, 4, 1)) +>foo : Symbol(foo, Decl(aliasErrors.ts, 0, 0)) + +import booz = foo.bar.baz; +>booz : Symbol(booz, Decl(aliasErrors.ts, 6, 21)) +>foo : Symbol(foo, Decl(aliasErrors.ts, 0, 0)) +>bar : Symbol(provide.bar, Decl(aliasErrors.ts, 2, 5)) +>baz : Symbol(booz, Decl(aliasErrors.ts, 3, 23)) + +import beez = foo.bar; +>beez : Symbol(beez, Decl(aliasErrors.ts, 7, 26)) +>foo : Symbol(foo, Decl(aliasErrors.ts, 0, 0)) +>bar : Symbol(provide.bar, Decl(aliasErrors.ts, 2, 5)) + +import m = no; +>m : Symbol(m, Decl(aliasErrors.ts, 8, 22)) + +import m2 = no.mod; +>m2 : Symbol(m2, Decl(aliasErrors.ts, 10, 14)) + +import n = 5; +>n : Symbol(n, Decl(aliasErrors.ts, 11, 19)) + +import o = "s"; +>o : Symbol(o, Decl(aliasErrors.ts, 12, 13)) + +import q = null; +>q : Symbol(q, Decl(aliasErrors.ts, 13, 15)) + +import r = undefined; +>r : Symbol(r, Decl(aliasErrors.ts, 14, 16)) + + +var p = new provide.Provide(); +>p : Symbol(p, Decl(aliasErrors.ts, 18, 3)) +>provide.Provide : Symbol(provide.Provide, Decl(aliasErrors.ts, 0, 12)) +>provide : Symbol(provide, Decl(aliasErrors.ts, 4, 1)) +>Provide : Symbol(provide.Provide, Decl(aliasErrors.ts, 0, 12)) + +function use() { +>use : Symbol(use, Decl(aliasErrors.ts, 18, 30)) + + beez.baz.boo; +>beez.baz.boo : Symbol(booz.boo, Decl(aliasErrors.ts, 3, 43)) +>beez.baz : Symbol(booz, Decl(aliasErrors.ts, 3, 23)) +>beez : Symbol(beez, Decl(aliasErrors.ts, 7, 26)) +>baz : Symbol(booz, Decl(aliasErrors.ts, 3, 23)) +>boo : Symbol(booz.boo, Decl(aliasErrors.ts, 3, 43)) + + var p1: provide.Provide; +>p1 : Symbol(p1, Decl(aliasErrors.ts, 23, 5)) +>provide : Symbol(provide, Decl(aliasErrors.ts, 4, 1)) +>Provide : Symbol(provide.Provide, Decl(aliasErrors.ts, 0, 12)) + + var p2: foo.Provide; +>p2 : Symbol(p2, Decl(aliasErrors.ts, 24, 5)) +>foo : Symbol(foo, Decl(aliasErrors.ts, 0, 0)) +>Provide : Symbol(provide.Provide, Decl(aliasErrors.ts, 0, 12)) + + var p3:booz.bar; +>p3 : Symbol(p3, Decl(aliasErrors.ts, 25, 5)) +>booz : Symbol(booz, Decl(aliasErrors.ts, 6, 21)) + + var p22 = new provide.Provide(); +>p22 : Symbol(p22, Decl(aliasErrors.ts, 26, 5)) +>provide.Provide : Symbol(provide.Provide, Decl(aliasErrors.ts, 0, 12)) +>provide : Symbol(provide, Decl(aliasErrors.ts, 4, 1)) +>Provide : Symbol(provide.Provide, Decl(aliasErrors.ts, 0, 12)) +} + + diff --git a/tests/baselines/reference/aliasErrors.types b/tests/baselines/reference/aliasErrors.types new file mode 100644 index 00000000000..6dc25ef9a33 --- /dev/null +++ b/tests/baselines/reference/aliasErrors.types @@ -0,0 +1,98 @@ +=== tests/cases/compiler/aliasErrors.ts === +module foo { +>foo : typeof foo + + export class Provide { +>Provide : Provide + } + export module bar { export module baz {export class boo {}}} +>bar : typeof bar +>baz : typeof baz +>boo : boo +} + +import provide = foo; +>provide : typeof foo +>foo : typeof foo + +import booz = foo.bar.baz; +>booz : typeof booz +>foo : typeof foo +>bar : typeof provide.bar +>baz : typeof booz + +import beez = foo.bar; +>beez : typeof provide.bar +>foo : typeof foo +>bar : typeof provide.bar + +import m = no; +>m : any +>no : No type information available! + +import m2 = no.mod; +>m2 : any +>no : No type information available! +>mod : No type information available! + +import n = 5; +>n : any +> : No type information available! +>5 : 5 + +import o = "s"; +>o : any +> : No type information available! +>"s" : "s" + +import q = null; +>q : any +> : No type information available! +>null : null + +import r = undefined; +>r : any +>undefined : No type information available! + + +var p = new provide.Provide(); +>p : provide.Provide +>new provide.Provide() : provide.Provide +>provide.Provide : typeof provide.Provide +>provide : typeof foo +>Provide : typeof provide.Provide + +function use() { +>use : () => void + + beez.baz.boo; +>beez.baz.boo : typeof booz.boo +>beez.baz : typeof booz +>beez : typeof provide.bar +>baz : typeof booz +>boo : typeof booz.boo + + var p1: provide.Provide; +>p1 : provide.Provide +>provide : any +>Provide : provide.Provide + + var p2: foo.Provide; +>p2 : provide.Provide +>foo : any +>Provide : provide.Provide + + var p3:booz.bar; +>p3 : any +>booz : any +>bar : No type information available! + + var p22 = new provide.Provide(); +>p22 : provide.Provide +>new provide.Provide() : provide.Provide +>provide.Provide : typeof provide.Provide +>provide : typeof foo +>Provide : typeof provide.Provide +} + + diff --git a/tests/baselines/reference/aliasInaccessibleModule.symbols b/tests/baselines/reference/aliasInaccessibleModule.symbols new file mode 100644 index 00000000000..d4424e275c9 --- /dev/null +++ b/tests/baselines/reference/aliasInaccessibleModule.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/aliasInaccessibleModule.ts === +module M { +>M : Symbol(M, Decl(aliasInaccessibleModule.ts, 0, 0)) + + module N { +>N : Symbol(N, Decl(aliasInaccessibleModule.ts, 0, 10)) + } + export import X = N; +>X : Symbol(X, Decl(aliasInaccessibleModule.ts, 2, 5)) +>N : Symbol(N, Decl(aliasInaccessibleModule.ts, 0, 10)) +} diff --git a/tests/baselines/reference/aliasInaccessibleModule.types b/tests/baselines/reference/aliasInaccessibleModule.types new file mode 100644 index 00000000000..fc5e85f37cb --- /dev/null +++ b/tests/baselines/reference/aliasInaccessibleModule.types @@ -0,0 +1,11 @@ +=== tests/cases/compiler/aliasInaccessibleModule.ts === +module M { +>M : typeof M + + module N { +>N : any + } + export import X = N; +>X : any +>N : any +} diff --git a/tests/baselines/reference/aliasInaccessibleModule2.symbols b/tests/baselines/reference/aliasInaccessibleModule2.symbols new file mode 100644 index 00000000000..b5025845d73 --- /dev/null +++ b/tests/baselines/reference/aliasInaccessibleModule2.symbols @@ -0,0 +1,20 @@ +=== tests/cases/compiler/aliasInaccessibleModule2.ts === +module M { +>M : Symbol(M, Decl(aliasInaccessibleModule2.ts, 0, 0)) + + module N { +>N : Symbol(N, Decl(aliasInaccessibleModule2.ts, 0, 10)) + + class C { +>C : Symbol(C, Decl(aliasInaccessibleModule2.ts, 1, 14)) + } + + } + import R = N; +>R : Symbol(R, Decl(aliasInaccessibleModule2.ts, 5, 5)) +>N : Symbol(N, Decl(aliasInaccessibleModule2.ts, 0, 10)) + + export import X = R; +>X : Symbol(X, Decl(aliasInaccessibleModule2.ts, 6, 17)) +>R : Symbol(R, Decl(aliasInaccessibleModule2.ts, 5, 5)) +} diff --git a/tests/baselines/reference/aliasInaccessibleModule2.types b/tests/baselines/reference/aliasInaccessibleModule2.types new file mode 100644 index 00000000000..1ad25ae0cf9 --- /dev/null +++ b/tests/baselines/reference/aliasInaccessibleModule2.types @@ -0,0 +1,20 @@ +=== tests/cases/compiler/aliasInaccessibleModule2.ts === +module M { +>M : typeof M + + module N { +>N : typeof N + + class C { +>C : C + } + + } + import R = N; +>R : typeof N +>N : typeof N + + export import X = R; +>X : typeof N +>R : typeof N +} diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.symbols b/tests/baselines/reference/aliasOnMergedModuleInterface.symbols new file mode 100644 index 00000000000..c4f5c0730a1 --- /dev/null +++ b/tests/baselines/reference/aliasOnMergedModuleInterface.symbols @@ -0,0 +1,42 @@ +=== tests/cases/compiler/aliasOnMergedModuleInterface_1.ts === +/// +import foo = require("foo") +>foo : Symbol(foo, Decl(aliasOnMergedModuleInterface_1.ts, 0, 0)) + +var z: foo; +>z : Symbol(z, Decl(aliasOnMergedModuleInterface_1.ts, 2, 3)) +>foo : Symbol(foo, Decl(aliasOnMergedModuleInterface_1.ts, 0, 0)) + +z.bar("hello"); // This should be ok +>z.bar : Symbol(foo.bar, Decl(aliasOnMergedModuleInterface_0.ts, 6, 17)) +>z : Symbol(z, Decl(aliasOnMergedModuleInterface_1.ts, 2, 3)) +>bar : Symbol(foo.bar, Decl(aliasOnMergedModuleInterface_0.ts, 6, 17)) + +var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error +>x : Symbol(x, Decl(aliasOnMergedModuleInterface_1.ts, 4, 3)) +>foo : Symbol(foo, Decl(aliasOnMergedModuleInterface_1.ts, 0, 0)) +>A : Symbol(foo.A, Decl(aliasOnMergedModuleInterface_0.ts, 2, 14)) + +=== tests/cases/compiler/aliasOnMergedModuleInterface_0.ts === +declare module "foo" +{ + module B { +>B : Symbol(B, Decl(aliasOnMergedModuleInterface_0.ts, 1, 1), Decl(aliasOnMergedModuleInterface_0.ts, 5, 5)) + + export interface A { +>A : Symbol(A, Decl(aliasOnMergedModuleInterface_0.ts, 2, 14)) + } + } + interface B { +>B : Symbol(B, Decl(aliasOnMergedModuleInterface_0.ts, 1, 1), Decl(aliasOnMergedModuleInterface_0.ts, 5, 5)) + + bar(name: string): B.A; +>bar : Symbol(B.bar, Decl(aliasOnMergedModuleInterface_0.ts, 6, 17)) +>name : Symbol(name, Decl(aliasOnMergedModuleInterface_0.ts, 7, 12)) +>B : Symbol(B, Decl(aliasOnMergedModuleInterface_0.ts, 1, 1), Decl(aliasOnMergedModuleInterface_0.ts, 5, 5)) +>A : Symbol(B.A, Decl(aliasOnMergedModuleInterface_0.ts, 2, 14)) + } + export = B; +>B : Symbol(B, Decl(aliasOnMergedModuleInterface_0.ts, 1, 1), Decl(aliasOnMergedModuleInterface_0.ts, 5, 5)) +} + diff --git a/tests/baselines/reference/aliasOnMergedModuleInterface.types b/tests/baselines/reference/aliasOnMergedModuleInterface.types new file mode 100644 index 00000000000..9ba023a8dd8 --- /dev/null +++ b/tests/baselines/reference/aliasOnMergedModuleInterface.types @@ -0,0 +1,49 @@ +=== tests/cases/compiler/aliasOnMergedModuleInterface_1.ts === +/// +import foo = require("foo") +>foo : any + +var z: foo; +>z : foo +>foo : foo + +z.bar("hello"); // This should be ok +>z.bar("hello") : foo.A +>z.bar : (name: string) => foo.A +>z : foo +>bar : (name: string) => foo.A +>"hello" : "hello" + +var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error +>x : foo.A +>foo : any +>A : foo.A +>foo.bar("hello") : any +>foo.bar : any +>foo : any +>bar : any +>"hello" : "hello" + +=== tests/cases/compiler/aliasOnMergedModuleInterface_0.ts === +declare module "foo" +{ + module B { +>B : any + + export interface A { +>A : A + } + } + interface B { +>B : B + + bar(name: string): B.A; +>bar : (name: string) => B.A +>name : string +>B : any +>A : B.A + } + export = B; +>B : B +} + diff --git a/tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.symbols b/tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.symbols new file mode 100644 index 00000000000..5d4ac0be473 --- /dev/null +++ b/tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/aliasWithInterfaceExportAssignmentUsedInVarInitializer_1.ts === +import moduleA = require("./aliasWithInterfaceExportAssignmentUsedInVarInitializer_0"); +>moduleA : Symbol(moduleA, Decl(aliasWithInterfaceExportAssignmentUsedInVarInitializer_1.ts, 0, 0)) + +var d = b.q3; +>d : Symbol(d, Decl(aliasWithInterfaceExportAssignmentUsedInVarInitializer_1.ts, 1, 3)) + +=== tests/cases/compiler/aliasWithInterfaceExportAssignmentUsedInVarInitializer_0.ts === +interface c { +>c : Symbol(c, Decl(aliasWithInterfaceExportAssignmentUsedInVarInitializer_0.ts, 0, 0)) + + q3: number; +>q3 : Symbol(c.q3, Decl(aliasWithInterfaceExportAssignmentUsedInVarInitializer_0.ts, 0, 13)) +} +export = c; +>c : Symbol(c, Decl(aliasWithInterfaceExportAssignmentUsedInVarInitializer_0.ts, 0, 0)) + diff --git a/tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.types b/tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.types new file mode 100644 index 00000000000..6a80fcc768c --- /dev/null +++ b/tests/baselines/reference/aliasWithInterfaceExportAssignmentUsedInVarInitializer.types @@ -0,0 +1,20 @@ +=== tests/cases/compiler/aliasWithInterfaceExportAssignmentUsedInVarInitializer_1.ts === +import moduleA = require("./aliasWithInterfaceExportAssignmentUsedInVarInitializer_0"); +>moduleA : any + +var d = b.q3; +>d : any +>b.q3 : any +>b : any +>q3 : any + +=== tests/cases/compiler/aliasWithInterfaceExportAssignmentUsedInVarInitializer_0.ts === +interface c { +>c : c + + q3: number; +>q3 : number +} +export = c; +>c : c + diff --git a/tests/baselines/reference/aliasesInSystemModule1.symbols b/tests/baselines/reference/aliasesInSystemModule1.symbols new file mode 100644 index 00000000000..fe5f4a550a6 --- /dev/null +++ b/tests/baselines/reference/aliasesInSystemModule1.symbols @@ -0,0 +1,47 @@ +=== tests/cases/compiler/aliasesInSystemModule1.ts === +import alias = require('foo'); +>alias : Symbol(alias, Decl(aliasesInSystemModule1.ts, 0, 0)) + +import cls = alias.Class; +>cls : Symbol(cls, Decl(aliasesInSystemModule1.ts, 0, 30)) +>alias : Symbol(alias, Decl(aliasesInSystemModule1.ts, 0, 0)) +>Class : Symbol(alias) + +export import cls2 = alias.Class; +>cls2 : Symbol(cls2, Decl(aliasesInSystemModule1.ts, 1, 25)) +>alias : Symbol(alias, Decl(aliasesInSystemModule1.ts, 0, 0)) +>Class : Symbol(alias) + +let x = new alias.Class(); +>x : Symbol(x, Decl(aliasesInSystemModule1.ts, 4, 3)) +>alias : Symbol(alias, Decl(aliasesInSystemModule1.ts, 0, 0)) + +let y = new cls(); +>y : Symbol(y, Decl(aliasesInSystemModule1.ts, 5, 3)) +>cls : Symbol(cls, Decl(aliasesInSystemModule1.ts, 0, 30)) + +let z = new cls2(); +>z : Symbol(z, Decl(aliasesInSystemModule1.ts, 6, 3)) +>cls2 : Symbol(cls2, Decl(aliasesInSystemModule1.ts, 1, 25)) + +module M { +>M : Symbol(M, Decl(aliasesInSystemModule1.ts, 6, 19)) + + export import cls = alias.Class; +>cls : Symbol(cls, Decl(aliasesInSystemModule1.ts, 8, 10)) +>alias : Symbol(alias, Decl(aliasesInSystemModule1.ts, 0, 0)) +>Class : Symbol(cls) + + let x = new alias.Class(); +>x : Symbol(x, Decl(aliasesInSystemModule1.ts, 10, 5)) +>alias : Symbol(alias, Decl(aliasesInSystemModule1.ts, 0, 0)) + + let y = new cls(); +>y : Symbol(y, Decl(aliasesInSystemModule1.ts, 11, 5)) +>cls : Symbol(cls, Decl(aliasesInSystemModule1.ts, 8, 10)) + + let z = new cls2(); +>z : Symbol(z, Decl(aliasesInSystemModule1.ts, 12, 5)) +>cls2 : Symbol(cls2, Decl(aliasesInSystemModule1.ts, 1, 25)) +} + diff --git a/tests/baselines/reference/aliasesInSystemModule1.types b/tests/baselines/reference/aliasesInSystemModule1.types new file mode 100644 index 00000000000..14ed376f20b --- /dev/null +++ b/tests/baselines/reference/aliasesInSystemModule1.types @@ -0,0 +1,57 @@ +=== tests/cases/compiler/aliasesInSystemModule1.ts === +import alias = require('foo'); +>alias : any + +import cls = alias.Class; +>cls : any +>alias : any +>Class : any + +export import cls2 = alias.Class; +>cls2 : any +>alias : any +>Class : any + +let x = new alias.Class(); +>x : any +>new alias.Class() : any +>alias.Class : any +>alias : any +>Class : any + +let y = new cls(); +>y : any +>new cls() : any +>cls : any + +let z = new cls2(); +>z : any +>new cls2() : any +>cls2 : any + +module M { +>M : typeof M + + export import cls = alias.Class; +>cls : any +>alias : any +>Class : any + + let x = new alias.Class(); +>x : any +>new alias.Class() : any +>alias.Class : any +>alias : any +>Class : any + + let y = new cls(); +>y : any +>new cls() : any +>cls : any + + let z = new cls2(); +>z : any +>new cls2() : any +>cls2 : any +} + diff --git a/tests/baselines/reference/aliasesInSystemModule2.symbols b/tests/baselines/reference/aliasesInSystemModule2.symbols new file mode 100644 index 00000000000..c40b0257104 --- /dev/null +++ b/tests/baselines/reference/aliasesInSystemModule2.symbols @@ -0,0 +1,46 @@ +=== tests/cases/compiler/aliasesInSystemModule2.ts === +import {alias} from "foo"; +>alias : Symbol(alias, Decl(aliasesInSystemModule2.ts, 0, 8)) + +import cls = alias.Class; +>cls : Symbol(cls, Decl(aliasesInSystemModule2.ts, 0, 26)) +>alias : Symbol(alias, Decl(aliasesInSystemModule2.ts, 0, 8)) +>Class : Symbol(alias) + +export import cls2 = alias.Class; +>cls2 : Symbol(cls2, Decl(aliasesInSystemModule2.ts, 1, 25)) +>alias : Symbol(alias, Decl(aliasesInSystemModule2.ts, 0, 8)) +>Class : Symbol(alias) + +let x = new alias.Class(); +>x : Symbol(x, Decl(aliasesInSystemModule2.ts, 4, 3)) +>alias : Symbol(alias, Decl(aliasesInSystemModule2.ts, 0, 8)) + +let y = new cls(); +>y : Symbol(y, Decl(aliasesInSystemModule2.ts, 5, 3)) +>cls : Symbol(cls, Decl(aliasesInSystemModule2.ts, 0, 26)) + +let z = new cls2(); +>z : Symbol(z, Decl(aliasesInSystemModule2.ts, 6, 3)) +>cls2 : Symbol(cls2, Decl(aliasesInSystemModule2.ts, 1, 25)) + +module M { +>M : Symbol(M, Decl(aliasesInSystemModule2.ts, 6, 19)) + + export import cls = alias.Class; +>cls : Symbol(cls, Decl(aliasesInSystemModule2.ts, 8, 10)) +>alias : Symbol(alias, Decl(aliasesInSystemModule2.ts, 0, 8)) +>Class : Symbol(cls) + + let x = new alias.Class(); +>x : Symbol(x, Decl(aliasesInSystemModule2.ts, 10, 5)) +>alias : Symbol(alias, Decl(aliasesInSystemModule2.ts, 0, 8)) + + let y = new cls(); +>y : Symbol(y, Decl(aliasesInSystemModule2.ts, 11, 5)) +>cls : Symbol(cls, Decl(aliasesInSystemModule2.ts, 8, 10)) + + let z = new cls2(); +>z : Symbol(z, Decl(aliasesInSystemModule2.ts, 12, 5)) +>cls2 : Symbol(cls2, Decl(aliasesInSystemModule2.ts, 1, 25)) +} diff --git a/tests/baselines/reference/aliasesInSystemModule2.types b/tests/baselines/reference/aliasesInSystemModule2.types new file mode 100644 index 00000000000..10009721222 --- /dev/null +++ b/tests/baselines/reference/aliasesInSystemModule2.types @@ -0,0 +1,56 @@ +=== tests/cases/compiler/aliasesInSystemModule2.ts === +import {alias} from "foo"; +>alias : any + +import cls = alias.Class; +>cls : any +>alias : any +>Class : any + +export import cls2 = alias.Class; +>cls2 : any +>alias : any +>Class : any + +let x = new alias.Class(); +>x : any +>new alias.Class() : any +>alias.Class : any +>alias : any +>Class : any + +let y = new cls(); +>y : any +>new cls() : any +>cls : any + +let z = new cls2(); +>z : any +>new cls2() : any +>cls2 : any + +module M { +>M : typeof M + + export import cls = alias.Class; +>cls : any +>alias : any +>Class : any + + let x = new alias.Class(); +>x : any +>new alias.Class() : any +>alias.Class : any +>alias : any +>Class : any + + let y = new cls(); +>y : any +>new cls() : any +>cls : any + + let z = new cls2(); +>z : any +>new cls2() : any +>cls2 : any +} diff --git a/tests/baselines/reference/allowSyntheticDefaultImports10.symbols b/tests/baselines/reference/allowSyntheticDefaultImports10.symbols new file mode 100644 index 00000000000..5c079cd8f74 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports10.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/a.ts === +import Foo = require("./b"); +>Foo : Symbol(Foo, Decl(a.ts, 0, 0)) + +Foo.default.bar(); +>Foo : Symbol(Foo, Decl(a.ts, 0, 0)) + +Foo.default.default.foo(); +>Foo : Symbol(Foo, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.d.ts === +export function foo(); +>foo : Symbol(foo, Decl(b.d.ts, 0, 0)) + +export function bar(); +>bar : Symbol(bar, Decl(b.d.ts, 0, 22)) + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports10.types b/tests/baselines/reference/allowSyntheticDefaultImports10.types new file mode 100644 index 00000000000..3262dfd66b7 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports10.types @@ -0,0 +1,29 @@ +=== tests/cases/compiler/a.ts === +import Foo = require("./b"); +>Foo : typeof Foo + +Foo.default.bar(); +>Foo.default.bar() : any +>Foo.default.bar : any +>Foo.default : any +>Foo : typeof Foo +>default : any +>bar : any + +Foo.default.default.foo(); +>Foo.default.default.foo() : any +>Foo.default.default.foo : any +>Foo.default.default : any +>Foo.default : any +>Foo : typeof Foo +>default : any +>default : any +>foo : any + +=== tests/cases/compiler/b.d.ts === +export function foo(); +>foo : () => any + +export function bar(); +>bar : () => any + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports3.symbols b/tests/baselines/reference/allowSyntheticDefaultImports3.symbols new file mode 100644 index 00000000000..4d5add178c8 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports3.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +import Namespace from "./b"; +>Namespace : Symbol(Namespace, Decl(a.ts, 0, 6)) + +export var x = new Namespace.Foo(); +>x : Symbol(x, Decl(a.ts, 1, 10)) +>Namespace : Symbol(Namespace, Decl(a.ts, 0, 6)) + +=== tests/cases/compiler/b.ts === +export class Foo { +>Foo : Symbol(Foo, Decl(b.ts, 0, 0)) + + member: string; +>member : Symbol(Foo.member, Decl(b.ts, 0, 18)) +} + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports3.types b/tests/baselines/reference/allowSyntheticDefaultImports3.types new file mode 100644 index 00000000000..e7af1777f16 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports3.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +import Namespace from "./b"; +>Namespace : any + +export var x = new Namespace.Foo(); +>x : any +>new Namespace.Foo() : any +>Namespace.Foo : any +>Namespace : any +>Foo : any + +=== tests/cases/compiler/b.ts === +export class Foo { +>Foo : Foo + + member: string; +>member : string +} + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports6.symbols b/tests/baselines/reference/allowSyntheticDefaultImports6.symbols new file mode 100644 index 00000000000..22887d48bd9 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports6.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/b.d.ts === +declare class Foo { +>Foo : Symbol(Foo, Decl(b.d.ts, 0, 0)) + + member: string; +>member : Symbol(Foo.member, Decl(b.d.ts, 0, 19)) +} +export = Foo; +>Foo : Symbol(Foo, Decl(b.d.ts, 0, 0)) + +=== tests/cases/compiler/a.ts === +import Foo from "./b"; +>Foo : Symbol(Foo, Decl(a.ts, 0, 6)) + +export var x = new Foo(); +>x : Symbol(x, Decl(a.ts, 1, 10)) +>Foo : Symbol(Foo, Decl(a.ts, 0, 6)) + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports6.types b/tests/baselines/reference/allowSyntheticDefaultImports6.types new file mode 100644 index 00000000000..8a70a0eef8c --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports6.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/b.d.ts === +declare class Foo { +>Foo : Foo + + member: string; +>member : string +} +export = Foo; +>Foo : Foo + +=== tests/cases/compiler/a.ts === +import Foo from "./b"; +>Foo : any + +export var x = new Foo(); +>x : any +>new Foo() : any +>Foo : any + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports8.symbols b/tests/baselines/reference/allowSyntheticDefaultImports8.symbols new file mode 100644 index 00000000000..cf5eece0999 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports8.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/b.d.ts === +export function foo(); +>foo : Symbol(foo, Decl(b.d.ts, 0, 0)) + +export function bar(); +>bar : Symbol(bar, Decl(b.d.ts, 0, 22)) + +=== tests/cases/compiler/a.ts === +import { default as Foo } from "./b"; +>default : Symbol(Foo, Decl(a.ts, 0, 8)) +>Foo : Symbol(Foo, Decl(a.ts, 0, 8)) + +Foo.bar(); +>Foo : Symbol(Foo, Decl(a.ts, 0, 8)) + +Foo.foo(); +>Foo : Symbol(Foo, Decl(a.ts, 0, 8)) + diff --git a/tests/baselines/reference/allowSyntheticDefaultImports8.types b/tests/baselines/reference/allowSyntheticDefaultImports8.types new file mode 100644 index 00000000000..38d2c03fba9 --- /dev/null +++ b/tests/baselines/reference/allowSyntheticDefaultImports8.types @@ -0,0 +1,24 @@ +=== tests/cases/compiler/b.d.ts === +export function foo(); +>foo : () => any + +export function bar(); +>bar : () => any + +=== tests/cases/compiler/a.ts === +import { default as Foo } from "./b"; +>default : any +>Foo : any + +Foo.bar(); +>Foo.bar() : any +>Foo.bar : any +>Foo : any +>bar : any + +Foo.foo(); +>Foo.foo() : any +>Foo.foo : any +>Foo : any +>foo : any + diff --git a/tests/baselines/reference/alwaysStrict.symbols b/tests/baselines/reference/alwaysStrict.symbols new file mode 100644 index 00000000000..f045db29e46 --- /dev/null +++ b/tests/baselines/reference/alwaysStrict.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/alwaysStrict.ts === +function f() { +>f : Symbol(f, Decl(alwaysStrict.ts, 0, 0)) + + var arguments = []; +>arguments : Symbol(arguments, Decl(alwaysStrict.ts, 1, 7)) +} diff --git a/tests/baselines/reference/alwaysStrict.types b/tests/baselines/reference/alwaysStrict.types new file mode 100644 index 00000000000..4cf345a244a --- /dev/null +++ b/tests/baselines/reference/alwaysStrict.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/alwaysStrict.ts === +function f() { +>f : () => void + + var arguments = []; +>arguments : any[] +>[] : undefined[] +} diff --git a/tests/baselines/reference/alwaysStrictES6.symbols b/tests/baselines/reference/alwaysStrictES6.symbols new file mode 100644 index 00000000000..540146bdad2 --- /dev/null +++ b/tests/baselines/reference/alwaysStrictES6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/alwaysStrictES6.ts === +function f() { +>f : Symbol(f, Decl(alwaysStrictES6.ts, 0, 0)) + + var arguments = []; +>arguments : Symbol(arguments, Decl(alwaysStrictES6.ts, 1, 7)) +} diff --git a/tests/baselines/reference/alwaysStrictES6.types b/tests/baselines/reference/alwaysStrictES6.types new file mode 100644 index 00000000000..832656d54bc --- /dev/null +++ b/tests/baselines/reference/alwaysStrictES6.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/alwaysStrictES6.ts === +function f() { +>f : () => void + + var arguments = []; +>arguments : any[] +>[] : undefined[] +} diff --git a/tests/baselines/reference/alwaysStrictModule.symbols b/tests/baselines/reference/alwaysStrictModule.symbols new file mode 100644 index 00000000000..0814d039bc6 --- /dev/null +++ b/tests/baselines/reference/alwaysStrictModule.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/alwaysStrictModule.ts === +module M { +>M : Symbol(M, Decl(alwaysStrictModule.ts, 0, 0)) + + export function f() { +>f : Symbol(f, Decl(alwaysStrictModule.ts, 0, 10)) + + var arguments = []; +>arguments : Symbol(arguments, Decl(alwaysStrictModule.ts, 2, 11)) + } +} diff --git a/tests/baselines/reference/alwaysStrictModule.types b/tests/baselines/reference/alwaysStrictModule.types new file mode 100644 index 00000000000..20d3a43bc1a --- /dev/null +++ b/tests/baselines/reference/alwaysStrictModule.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/alwaysStrictModule.ts === +module M { +>M : typeof M + + export function f() { +>f : () => void + + var arguments = []; +>arguments : any[] +>[] : undefined[] + } +} diff --git a/tests/baselines/reference/alwaysStrictModule2.symbols b/tests/baselines/reference/alwaysStrictModule2.symbols new file mode 100644 index 00000000000..e25fc11ec19 --- /dev/null +++ b/tests/baselines/reference/alwaysStrictModule2.symbols @@ -0,0 +1,23 @@ +=== tests/cases/compiler/a.ts === +module M { +>M : Symbol(M, Decl(a.ts, 0, 0), Decl(b.ts, 0, 0)) + + export function f() { +>f : Symbol(f, Decl(a.ts, 0, 10)) + + var arguments = []; +>arguments : Symbol(arguments, Decl(a.ts, 2, 11)) + } +} + +=== tests/cases/compiler/b.ts === +module M { +>M : Symbol(M, Decl(a.ts, 0, 0), Decl(b.ts, 0, 0)) + + export function f2() { +>f2 : Symbol(f2, Decl(b.ts, 0, 10)) + + var arguments = []; +>arguments : Symbol(arguments, Decl(b.ts, 2, 11)) + } +} diff --git a/tests/baselines/reference/alwaysStrictModule2.types b/tests/baselines/reference/alwaysStrictModule2.types new file mode 100644 index 00000000000..494c38b90f9 --- /dev/null +++ b/tests/baselines/reference/alwaysStrictModule2.types @@ -0,0 +1,25 @@ +=== tests/cases/compiler/a.ts === +module M { +>M : typeof M + + export function f() { +>f : () => void + + var arguments = []; +>arguments : any[] +>[] : undefined[] + } +} + +=== tests/cases/compiler/b.ts === +module M { +>M : typeof M + + export function f2() { +>f2 : () => void + + var arguments = []; +>arguments : any[] +>[] : undefined[] + } +} diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.symbols b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.symbols new file mode 100644 index 00000000000..3b799d34f6e --- /dev/null +++ b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts === +module M { +>M : Symbol(M, Decl(alwaysStrictNoImplicitUseStrict.ts, 0, 0)) + + export function f() { +>f : Symbol(f, Decl(alwaysStrictNoImplicitUseStrict.ts, 0, 10)) + + var arguments = []; +>arguments : Symbol(arguments, Decl(alwaysStrictNoImplicitUseStrict.ts, 2, 11)) + } +} diff --git a/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.types b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.types new file mode 100644 index 00000000000..3ce5e15ed3a --- /dev/null +++ b/tests/baselines/reference/alwaysStrictNoImplicitUseStrict.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/alwaysStrictNoImplicitUseStrict.ts === +module M { +>M : typeof M + + export function f() { +>f : () => void + + var arguments = []; +>arguments : any[] +>[] : undefined[] + } +} diff --git a/tests/baselines/reference/ambientClassOverloadForFunction.symbols b/tests/baselines/reference/ambientClassOverloadForFunction.symbols new file mode 100644 index 00000000000..7ba3fa34593 --- /dev/null +++ b/tests/baselines/reference/ambientClassOverloadForFunction.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ambientClassOverloadForFunction.ts === +declare class foo{}; +>foo : Symbol(foo, Decl(ambientClassOverloadForFunction.ts, 0, 0)) + +function foo() { return null; } +>foo : Symbol(foo, Decl(ambientClassOverloadForFunction.ts, 0, 20)) + diff --git a/tests/baselines/reference/ambientClassOverloadForFunction.types b/tests/baselines/reference/ambientClassOverloadForFunction.types new file mode 100644 index 00000000000..fef745bd971 --- /dev/null +++ b/tests/baselines/reference/ambientClassOverloadForFunction.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ambientClassOverloadForFunction.ts === +declare class foo{}; +>foo : foo + +function foo() { return null; } +>foo : () => any +>null : null + diff --git a/tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.symbols b/tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.symbols new file mode 100644 index 00000000000..63d50b6c85e --- /dev/null +++ b/tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/ambient/ambientDeclarationsPatterns_tooManyAsterisks.ts === +declare module "too*many*asterisks" { } +No type information for this code. +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.types b/tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.types new file mode 100644 index 00000000000..63d50b6c85e --- /dev/null +++ b/tests/baselines/reference/ambientDeclarationsPatterns_tooManyAsterisks.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/ambient/ambientDeclarationsPatterns_tooManyAsterisks.ts === +declare module "too*many*asterisks" { } +No type information for this code. +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/ambientEnum1.symbols b/tests/baselines/reference/ambientEnum1.symbols new file mode 100644 index 00000000000..46116c4de19 --- /dev/null +++ b/tests/baselines/reference/ambientEnum1.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/ambientEnum1.ts === + declare enum E1 { +>E1 : Symbol(E1, Decl(ambientEnum1.ts, 0, 0)) + + y = 4.23 +>y : Symbol(E1.y, Decl(ambientEnum1.ts, 0, 21)) + } + + // Ambient enum with computer member + declare enum E2 { +>E2 : Symbol(E2, Decl(ambientEnum1.ts, 2, 5)) + + x = 'foo'.length +>x : Symbol(E2.x, Decl(ambientEnum1.ts, 5, 21)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) + } diff --git a/tests/baselines/reference/ambientEnum1.types b/tests/baselines/reference/ambientEnum1.types new file mode 100644 index 00000000000..968299f4d0a --- /dev/null +++ b/tests/baselines/reference/ambientEnum1.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/ambientEnum1.ts === + declare enum E1 { +>E1 : E1 + + y = 4.23 +>y : E1 +>4.23 : 4.23 + } + + // Ambient enum with computer member + declare enum E2 { +>E2 : E2 + + x = 'foo'.length +>x : E2 +>'foo'.length : number +>'foo' : "foo" +>length : number + } diff --git a/tests/baselines/reference/ambientErrors.symbols b/tests/baselines/reference/ambientErrors.symbols new file mode 100644 index 00000000000..684e87b1fd4 --- /dev/null +++ b/tests/baselines/reference/ambientErrors.symbols @@ -0,0 +1,109 @@ +=== tests/cases/conformance/ambient/ambientErrors.ts === +// Ambient variable with an initializer +declare var x = 4; +>x : Symbol(x, Decl(ambientErrors.ts, 1, 11)) + +// Ambient functions with invalid overloads +declare function fn(x: number): string; +>fn : Symbol(fn, Decl(ambientErrors.ts, 1, 18), Decl(ambientErrors.ts, 4, 39)) +>x : Symbol(x, Decl(ambientErrors.ts, 4, 20)) + +declare function fn(x: 'foo'): number; +>fn : Symbol(fn, Decl(ambientErrors.ts, 1, 18), Decl(ambientErrors.ts, 4, 39)) +>x : Symbol(x, Decl(ambientErrors.ts, 5, 20)) + +// Ambient functions with duplicate signatures +declare function fn1(x: number): string; +>fn1 : Symbol(fn1, Decl(ambientErrors.ts, 5, 38), Decl(ambientErrors.ts, 8, 40)) +>x : Symbol(x, Decl(ambientErrors.ts, 8, 21)) + +declare function fn1(x: number): string; +>fn1 : Symbol(fn1, Decl(ambientErrors.ts, 5, 38), Decl(ambientErrors.ts, 8, 40)) +>x : Symbol(x, Decl(ambientErrors.ts, 9, 21)) + +// Ambient function overloads that differ only by return type +declare function fn2(x: number): string; +>fn2 : Symbol(fn2, Decl(ambientErrors.ts, 9, 40), Decl(ambientErrors.ts, 12, 40)) +>x : Symbol(x, Decl(ambientErrors.ts, 12, 21)) + +declare function fn2(x: number): number; +>fn2 : Symbol(fn2, Decl(ambientErrors.ts, 9, 40), Decl(ambientErrors.ts, 12, 40)) +>x : Symbol(x, Decl(ambientErrors.ts, 13, 21)) + +// Ambient function with default parameter values +declare function fn3(x = 3); +>fn3 : Symbol(fn3, Decl(ambientErrors.ts, 13, 40)) +>x : Symbol(x, Decl(ambientErrors.ts, 16, 21)) + +// Ambient function with function body +declare function fn4() { }; +>fn4 : Symbol(fn4, Decl(ambientErrors.ts, 16, 28)) + +// Ambient enum with non - integer literal constant member +declare enum E1 { +>E1 : Symbol(E1, Decl(ambientErrors.ts, 19, 27)) + + y = 4.23 +>y : Symbol(E1.y, Decl(ambientErrors.ts, 22, 17)) +} + +// Ambient enum with computer member +declare enum E2 { +>E2 : Symbol(E2, Decl(ambientErrors.ts, 24, 1)) + + x = 'foo'.length +>x : Symbol(E2.x, Decl(ambientErrors.ts, 27, 17)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) +} + +// Ambient module with initializers for values, bodies for functions / classes +declare module M1 { +>M1 : Symbol(M1, Decl(ambientErrors.ts, 29, 1)) + + var x = 3; +>x : Symbol(x, Decl(ambientErrors.ts, 33, 7)) + + function fn() { } +>fn : Symbol(fn, Decl(ambientErrors.ts, 33, 14)) + + class C { +>C : Symbol(C, Decl(ambientErrors.ts, 34, 21)) + + static x = 3; +>x : Symbol(C.x, Decl(ambientErrors.ts, 35, 13)) + + y = 4; +>y : Symbol(C.y, Decl(ambientErrors.ts, 36, 21)) + + constructor() { } + fn() { } +>fn : Symbol(C.fn, Decl(ambientErrors.ts, 38, 25)) + + static sfn() { } +>sfn : Symbol(C.sfn, Decl(ambientErrors.ts, 39, 16)) + } +} + +// Ambient external module not in the global module +module M2 { +>M2 : Symbol(M2, Decl(ambientErrors.ts, 42, 1)) + + declare module 'nope' { } +} + +// Ambient external module with a string literal name that isn't a top level external module name +declare module '../foo' { } + +// Ambient external module with export assignment and other exported members +declare module 'bar' { + var n; +>n : Symbol(n, Decl(ambientErrors.ts, 54, 7)) + + export var q; +>q : Symbol(q, Decl(ambientErrors.ts, 55, 14)) + + export = n; +>n : Symbol(n, Decl(ambientErrors.ts, 54, 7)) +} + diff --git a/tests/baselines/reference/ambientErrors.types b/tests/baselines/reference/ambientErrors.types new file mode 100644 index 00000000000..3cd46066219 --- /dev/null +++ b/tests/baselines/reference/ambientErrors.types @@ -0,0 +1,116 @@ +=== tests/cases/conformance/ambient/ambientErrors.ts === +// Ambient variable with an initializer +declare var x = 4; +>x : number +>4 : 4 + +// Ambient functions with invalid overloads +declare function fn(x: number): string; +>fn : { (x: number): string; (x: "foo"): number; } +>x : number + +declare function fn(x: 'foo'): number; +>fn : { (x: number): string; (x: "foo"): number; } +>x : "foo" + +// Ambient functions with duplicate signatures +declare function fn1(x: number): string; +>fn1 : { (x: number): string; (x: number): string; } +>x : number + +declare function fn1(x: number): string; +>fn1 : { (x: number): string; (x: number): string; } +>x : number + +// Ambient function overloads that differ only by return type +declare function fn2(x: number): string; +>fn2 : { (x: number): string; (x: number): number; } +>x : number + +declare function fn2(x: number): number; +>fn2 : { (x: number): string; (x: number): number; } +>x : number + +// Ambient function with default parameter values +declare function fn3(x = 3); +>fn3 : (x?: number) => any +>x : number +>3 : 3 + +// Ambient function with function body +declare function fn4() { }; +>fn4 : () => void + +// Ambient enum with non - integer literal constant member +declare enum E1 { +>E1 : E1 + + y = 4.23 +>y : E1 +>4.23 : 4.23 +} + +// Ambient enum with computer member +declare enum E2 { +>E2 : E2 + + x = 'foo'.length +>x : E2 +>'foo'.length : number +>'foo' : "foo" +>length : number +} + +// Ambient module with initializers for values, bodies for functions / classes +declare module M1 { +>M1 : typeof M1 + + var x = 3; +>x : number +>3 : 3 + + function fn() { } +>fn : () => void + + class C { +>C : C + + static x = 3; +>x : number +>3 : 3 + + y = 4; +>y : number +>4 : 4 + + constructor() { } + fn() { } +>fn : () => void + + static sfn() { } +>sfn : () => void + } +} + +// Ambient external module not in the global module +module M2 { +>M2 : any + + declare module 'nope' { } +} + +// Ambient external module with a string literal name that isn't a top level external module name +declare module '../foo' { } + +// Ambient external module with export assignment and other exported members +declare module 'bar' { + var n; +>n : any + + export var q; +>q : any + + export = n; +>n : any +} + diff --git a/tests/baselines/reference/ambientErrors1.symbols b/tests/baselines/reference/ambientErrors1.symbols new file mode 100644 index 00000000000..65efc571619 --- /dev/null +++ b/tests/baselines/reference/ambientErrors1.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/ambientErrors1.ts === +declare var x = 4; +>x : Symbol(x, Decl(ambientErrors1.ts, 0, 11)) + diff --git a/tests/baselines/reference/ambientErrors1.types b/tests/baselines/reference/ambientErrors1.types new file mode 100644 index 00000000000..edf186a9024 --- /dev/null +++ b/tests/baselines/reference/ambientErrors1.types @@ -0,0 +1,5 @@ +=== tests/cases/compiler/ambientErrors1.ts === +declare var x = 4; +>x : number +>4 : 4 + diff --git a/tests/baselines/reference/ambientExportDefaultErrors.symbols b/tests/baselines/reference/ambientExportDefaultErrors.symbols new file mode 100644 index 00000000000..bfec3520347 --- /dev/null +++ b/tests/baselines/reference/ambientExportDefaultErrors.symbols @@ -0,0 +1,33 @@ +=== tests/cases/compiler/consumer.ts === +/// +No type information for this code./// +No type information for this code.import "indirect"; +No type information for this code.import "foo"; +No type information for this code.import "indirect2"; +No type information for this code.import "foo2"; +No type information for this code.=== tests/cases/compiler/foo.d.ts === +export default 2 + 2; +export as namespace Foo; +>Foo : Symbol(Foo, Decl(foo.d.ts, 0, 21)) + +=== tests/cases/compiler/foo2.d.ts === +export = 2 + 2; +export as namespace Foo2; +>Foo2 : Symbol(Foo2, Decl(foo2.d.ts, 0, 15)) + +=== tests/cases/compiler/indirection.d.ts === +/// +declare module "indirect" { + export default typeof Foo.default; +>Foo.default : Symbol(Foo.default, Decl(foo.d.ts, 0, 0)) +>Foo : Symbol(Foo, Decl(foo.d.ts, 0, 21)) +>default : Symbol(Foo.default, Decl(foo.d.ts, 0, 0)) +} + +=== tests/cases/compiler/indirection2.d.ts === +/// +declare module "indirect2" { + export = typeof Foo2; +>Foo2 : Symbol(Foo2, Decl(foo2.d.ts, 0, 15)) +} + diff --git a/tests/baselines/reference/ambientExportDefaultErrors.types b/tests/baselines/reference/ambientExportDefaultErrors.types new file mode 100644 index 00000000000..97d2051a70a --- /dev/null +++ b/tests/baselines/reference/ambientExportDefaultErrors.types @@ -0,0 +1,43 @@ +=== tests/cases/compiler/consumer.ts === +/// +No type information for this code./// +No type information for this code.import "indirect"; +No type information for this code.import "foo"; +No type information for this code.import "indirect2"; +No type information for this code.import "foo2"; +No type information for this code.=== tests/cases/compiler/foo.d.ts === +export default 2 + 2; +>2 + 2 : number +>2 : 2 +>2 : 2 + +export as namespace Foo; +>Foo : typeof "tests/cases/compiler/foo" + +=== tests/cases/compiler/foo2.d.ts === +export = 2 + 2; +>2 + 2 : number +>2 : 2 +>2 : 2 + +export as namespace Foo2; +>Foo2 : number + +=== tests/cases/compiler/indirection.d.ts === +/// +declare module "indirect" { + export default typeof Foo.default; +>typeof Foo.default : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function" +>Foo.default : number +>Foo : typeof Foo +>default : number +} + +=== tests/cases/compiler/indirection2.d.ts === +/// +declare module "indirect2" { + export = typeof Foo2; +>typeof Foo2 : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function" +>Foo2 : number +} + diff --git a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.symbols b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.symbols new file mode 100644 index 00000000000..7ab22e063e3 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.symbols @@ -0,0 +1,20 @@ +=== tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts === +class D { } +>D : Symbol(D, Decl(ambientExternalModuleInAnotherExternalModule.ts, 0, 0)) + +export = D; +>D : Symbol(D, Decl(ambientExternalModuleInAnotherExternalModule.ts, 0, 0)) + +declare module "ext" { + export class C { } +>C : Symbol(C, Decl(ambientExternalModuleInAnotherExternalModule.ts, 3, 22)) +} + +// Cannot resolve this ext module reference +import ext = require("ext"); +>ext : Symbol(ext, Decl(ambientExternalModuleInAnotherExternalModule.ts, 5, 1)) + +var x = ext; +>x : Symbol(x, Decl(ambientExternalModuleInAnotherExternalModule.ts, 9, 3)) +>ext : Symbol(ext, Decl(ambientExternalModuleInAnotherExternalModule.ts, 5, 1)) + diff --git a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.types b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.types new file mode 100644 index 00000000000..e7d852d7a3d --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.types @@ -0,0 +1,20 @@ +=== tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts === +class D { } +>D : D + +export = D; +>D : D + +declare module "ext" { + export class C { } +>C : C +} + +// Cannot resolve this ext module reference +import ext = require("ext"); +>ext : any + +var x = ext; +>x : any +>ext : any + diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.symbols b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.symbols new file mode 100644 index 00000000000..a2b535c5b80 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts === +module M { +>M : Symbol(M, Decl(ambientExternalModuleInsideNonAmbient.ts, 0, 0)) + + export declare module "M" { } +} diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.types b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.types new file mode 100644 index 00000000000..d635bfd1d1e --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts === +module M { +>M : any + + export declare module "M" { } +} diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.symbols b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.symbols new file mode 100644 index 00000000000..10841ebc4cd --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.symbols @@ -0,0 +1,3 @@ +=== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts === +export declare module "M" { } +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.types b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.types new file mode 100644 index 00000000000..10841ebc4cd --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.types @@ -0,0 +1,3 @@ +=== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts === +export declare module "M" { } +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.symbols b/tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.symbols new file mode 100644 index 00000000000..1e8ad3c5fa5 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.symbols @@ -0,0 +1,24 @@ +=== tests/cases/compiler/ambientExternalModuleWithRelativeExternalImportDeclaration.ts === +declare module "OuterModule" { + import m2 = require("./SubModule"); +>m2 : Symbol(m2, Decl(ambientExternalModuleWithRelativeExternalImportDeclaration.ts, 0, 30)) + + class SubModule { +>SubModule : Symbol(SubModule, Decl(ambientExternalModuleWithRelativeExternalImportDeclaration.ts, 1, 39)) + + public static StaticVar: number; +>StaticVar : Symbol(SubModule.StaticVar, Decl(ambientExternalModuleWithRelativeExternalImportDeclaration.ts, 2, 21)) + + public InstanceVar: number; +>InstanceVar : Symbol(SubModule.InstanceVar, Decl(ambientExternalModuleWithRelativeExternalImportDeclaration.ts, 3, 40)) + + public x: m2.c; +>x : Symbol(SubModule.x, Decl(ambientExternalModuleWithRelativeExternalImportDeclaration.ts, 4, 35)) +>m2 : Symbol(m2, Decl(ambientExternalModuleWithRelativeExternalImportDeclaration.ts, 0, 30)) +>c : Symbol(m2) + + constructor(); + } + export = SubModule; +>SubModule : Symbol(SubModule, Decl(ambientExternalModuleWithRelativeExternalImportDeclaration.ts, 1, 39)) +} diff --git a/tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.types b/tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.types new file mode 100644 index 00000000000..0d173e5e7a9 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleWithRelativeExternalImportDeclaration.types @@ -0,0 +1,24 @@ +=== tests/cases/compiler/ambientExternalModuleWithRelativeExternalImportDeclaration.ts === +declare module "OuterModule" { + import m2 = require("./SubModule"); +>m2 : any + + class SubModule { +>SubModule : SubModule + + public static StaticVar: number; +>StaticVar : number + + public InstanceVar: number; +>InstanceVar : number + + public x: m2.c; +>x : any +>m2 : any +>c : any + + constructor(); + } + export = SubModule; +>SubModule : SubModule +} diff --git a/tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.symbols b/tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.symbols new file mode 100644 index 00000000000..a8ef371e805 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/ambientExternalModuleWithRelativeModuleName.ts === +declare module "./relativeModule" { + var x: string; +>x : Symbol(x, Decl(ambientExternalModuleWithRelativeModuleName.ts, 1, 7)) +} + +declare module ".\\relativeModule" { + var x: string; +>x : Symbol(x, Decl(ambientExternalModuleWithRelativeModuleName.ts, 5, 7)) +} diff --git a/tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.types b/tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.types new file mode 100644 index 00000000000..ab0f2b62f58 --- /dev/null +++ b/tests/baselines/reference/ambientExternalModuleWithRelativeModuleName.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/ambientExternalModuleWithRelativeModuleName.ts === +declare module "./relativeModule" { + var x: string; +>x : string +} + +declare module ".\\relativeModule" { + var x: string; +>x : string +} diff --git a/tests/baselines/reference/ambientGetters.symbols b/tests/baselines/reference/ambientGetters.symbols new file mode 100644 index 00000000000..39a34e1d10b --- /dev/null +++ b/tests/baselines/reference/ambientGetters.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/ambientGetters.ts === +declare class A { +>A : Symbol(A, Decl(ambientGetters.ts, 0, 0)) + + get length() : number; +>length : Symbol(A.length, Decl(ambientGetters.ts, 0, 17)) +} + +declare class B { +>B : Symbol(B, Decl(ambientGetters.ts, 2, 1)) + + get length() { return 0; } +>length : Symbol(B.length, Decl(ambientGetters.ts, 4, 17)) +} diff --git a/tests/baselines/reference/ambientGetters.types b/tests/baselines/reference/ambientGetters.types new file mode 100644 index 00000000000..369742daba5 --- /dev/null +++ b/tests/baselines/reference/ambientGetters.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/ambientGetters.ts === +declare class A { +>A : A + + get length() : number; +>length : number +} + +declare class B { +>B : B + + get length() { return 0; } +>length : number +>0 : 0 +} diff --git a/tests/baselines/reference/ambientStatement1.symbols b/tests/baselines/reference/ambientStatement1.symbols new file mode 100644 index 00000000000..8e05372693c --- /dev/null +++ b/tests/baselines/reference/ambientStatement1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/ambientStatement1.ts === + declare module M1 { +>M1 : Symbol(M1, Decl(ambientStatement1.ts, 0, 0)) + + while(true); + + export var v1 = () => false; +>v1 : Symbol(v1, Decl(ambientStatement1.ts, 3, 15)) + } diff --git a/tests/baselines/reference/ambientStatement1.types b/tests/baselines/reference/ambientStatement1.types new file mode 100644 index 00000000000..da6b2ffc445 --- /dev/null +++ b/tests/baselines/reference/ambientStatement1.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/ambientStatement1.ts === + declare module M1 { +>M1 : typeof M1 + + while(true); +>true : true + + export var v1 = () => false; +>v1 : () => boolean +>() => false : () => boolean +>false : false + } diff --git a/tests/baselines/reference/ambientWithStatements.symbols b/tests/baselines/reference/ambientWithStatements.symbols new file mode 100644 index 00000000000..c5312f356ef --- /dev/null +++ b/tests/baselines/reference/ambientWithStatements.symbols @@ -0,0 +1,40 @@ +=== tests/cases/compiler/ambientWithStatements.ts === +declare module M { +>M : Symbol(M, Decl(ambientWithStatements.ts, 0, 0)) + + break; + continue; + debugger; + do { } while (true); + var x; +>x : Symbol(x, Decl(ambientWithStatements.ts, 5, 7)) + + for (x in null) { } +>x : Symbol(x, Decl(ambientWithStatements.ts, 5, 7)) + + if (true) { } else { } + 1; + L: var y; +>y : Symbol(y, Decl(ambientWithStatements.ts, 9, 10)) + + return; + switch (x) { +>x : Symbol(x, Decl(ambientWithStatements.ts, 5, 7)) + + case 1: + break; + default: + break; + } + throw "nooo"; + try { + } + catch (e) { +>e : Symbol(e, Decl(ambientWithStatements.ts, 20, 11)) + } + finally { + } + with (x) { +>x : Symbol(x, Decl(ambientWithStatements.ts, 5, 7)) + } +} diff --git a/tests/baselines/reference/ambientWithStatements.types b/tests/baselines/reference/ambientWithStatements.types new file mode 100644 index 00000000000..0769200aeb8 --- /dev/null +++ b/tests/baselines/reference/ambientWithStatements.types @@ -0,0 +1,52 @@ +=== tests/cases/compiler/ambientWithStatements.ts === +declare module M { +>M : typeof M + + break; + continue; + debugger; + do { } while (true); +>true : true + + var x; +>x : any + + for (x in null) { } +>x : any +>null : null + + if (true) { } else { } +>true : true + + 1; +>1 : 1 + + L: var y; +>L : any +>y : any + + return; + switch (x) { +>x : any + + case 1: +>1 : 1 + + break; + default: + break; + } + throw "nooo"; +>"nooo" : "nooo" + + try { + } + catch (e) { +>e : any + } + finally { + } + with (x) { +>x : any + } +} diff --git a/tests/baselines/reference/ambiguousGenericAssertion1.symbols b/tests/baselines/reference/ambiguousGenericAssertion1.symbols new file mode 100644 index 00000000000..dab5bcbc4eb --- /dev/null +++ b/tests/baselines/reference/ambiguousGenericAssertion1.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/ambiguousGenericAssertion1.ts === +function f(x: T): T { return null; } +>f : Symbol(f, Decl(ambiguousGenericAssertion1.ts, 0, 0)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 0, 11)) +>x : Symbol(x, Decl(ambiguousGenericAssertion1.ts, 0, 14)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 0, 11)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 0, 11)) + +var r = (x: T) => x; +>r : Symbol(r, Decl(ambiguousGenericAssertion1.ts, 1, 3)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 1, 9)) +>x : Symbol(x, Decl(ambiguousGenericAssertion1.ts, 1, 12)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 1, 9)) +>x : Symbol(x, Decl(ambiguousGenericAssertion1.ts, 1, 12)) + +var r2 = < (x: T) => T>f; // valid +>r2 : Symbol(r2, Decl(ambiguousGenericAssertion1.ts, 2, 3)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 2, 12)) +>x : Symbol(x, Decl(ambiguousGenericAssertion1.ts, 2, 15)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 2, 12)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 2, 12)) +>f : Symbol(f, Decl(ambiguousGenericAssertion1.ts, 0, 0)) + +var r3 = <(x: T) => T>f; // ambiguous, appears to the parser as a << operation +>r3 : Symbol(r3, Decl(ambiguousGenericAssertion1.ts, 3, 3)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 3, 16)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 3, 16)) +>T : Symbol(T, Decl(ambiguousGenericAssertion1.ts, 3, 16)) +>f : Symbol(f, Decl(ambiguousGenericAssertion1.ts, 0, 0)) + diff --git a/tests/baselines/reference/ambiguousGenericAssertion1.types b/tests/baselines/reference/ambiguousGenericAssertion1.types new file mode 100644 index 00000000000..380de5b7e1c --- /dev/null +++ b/tests/baselines/reference/ambiguousGenericAssertion1.types @@ -0,0 +1,39 @@ +=== tests/cases/compiler/ambiguousGenericAssertion1.ts === +function f(x: T): T { return null; } +>f : (x: T) => T +>T : T +>x : T +>T : T +>T : T +>null : null + +var r = (x: T) => x; +>r : (x: T) => T +>(x: T) => x : (x: T) => T +>T : T +>x : T +>T : T +>x : T + +var r2 = < (x: T) => T>f; // valid +>r2 : (x: T) => T +>< (x: T) => T>f : (x: T) => T +>T : T +>x : T +>T : T +>T : T +>f : (x: T) => T + +var r3 = <(x: T) => T>f; // ambiguous, appears to the parser as a << operation +>r3 : boolean +><(x : boolean +>< : any +>T : any +>(x : any +>x : any +>T : any +>T>f : boolean +>T : any +>f : (x: T) => T + diff --git a/tests/baselines/reference/ambiguousOverload.symbols b/tests/baselines/reference/ambiguousOverload.symbols new file mode 100644 index 00000000000..cddb82a7078 --- /dev/null +++ b/tests/baselines/reference/ambiguousOverload.symbols @@ -0,0 +1,47 @@ +=== tests/cases/compiler/ambiguousOverload.ts === +function foof(bar: string, y): number; +>foof : Symbol(foof, Decl(ambiguousOverload.ts, 0, 0), Decl(ambiguousOverload.ts, 0, 38), Decl(ambiguousOverload.ts, 1, 38)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 0, 14)) +>y : Symbol(y, Decl(ambiguousOverload.ts, 0, 26)) + +function foof(bar: string, x): string; +>foof : Symbol(foof, Decl(ambiguousOverload.ts, 0, 0), Decl(ambiguousOverload.ts, 0, 38), Decl(ambiguousOverload.ts, 1, 38)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 1, 14)) +>x : Symbol(x, Decl(ambiguousOverload.ts, 1, 26)) + +function foof(bar: any): any { return bar }; +>foof : Symbol(foof, Decl(ambiguousOverload.ts, 0, 0), Decl(ambiguousOverload.ts, 0, 38), Decl(ambiguousOverload.ts, 1, 38)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 2, 14)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 2, 14)) + +var x: number = foof("s", null); +>x : Symbol(x, Decl(ambiguousOverload.ts, 3, 3)) +>foof : Symbol(foof, Decl(ambiguousOverload.ts, 0, 0), Decl(ambiguousOverload.ts, 0, 38), Decl(ambiguousOverload.ts, 1, 38)) + +var y: string = foof("s", null); +>y : Symbol(y, Decl(ambiguousOverload.ts, 4, 3)) +>foof : Symbol(foof, Decl(ambiguousOverload.ts, 0, 0), Decl(ambiguousOverload.ts, 0, 38), Decl(ambiguousOverload.ts, 1, 38)) + +function foof2(bar: string, x): string; +>foof2 : Symbol(foof2, Decl(ambiguousOverload.ts, 4, 32), Decl(ambiguousOverload.ts, 6, 39), Decl(ambiguousOverload.ts, 7, 39)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 6, 15)) +>x : Symbol(x, Decl(ambiguousOverload.ts, 6, 27)) + +function foof2(bar: string, y): number; +>foof2 : Symbol(foof2, Decl(ambiguousOverload.ts, 4, 32), Decl(ambiguousOverload.ts, 6, 39), Decl(ambiguousOverload.ts, 7, 39)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 7, 15)) +>y : Symbol(y, Decl(ambiguousOverload.ts, 7, 27)) + +function foof2(bar: any): any { return bar }; +>foof2 : Symbol(foof2, Decl(ambiguousOverload.ts, 4, 32), Decl(ambiguousOverload.ts, 6, 39), Decl(ambiguousOverload.ts, 7, 39)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 8, 15)) +>bar : Symbol(bar, Decl(ambiguousOverload.ts, 8, 15)) + +var x2: string = foof2("s", null); +>x2 : Symbol(x2, Decl(ambiguousOverload.ts, 9, 3)) +>foof2 : Symbol(foof2, Decl(ambiguousOverload.ts, 4, 32), Decl(ambiguousOverload.ts, 6, 39), Decl(ambiguousOverload.ts, 7, 39)) + +var y2: number = foof2("s", null); +>y2 : Symbol(y2, Decl(ambiguousOverload.ts, 10, 3)) +>foof2 : Symbol(foof2, Decl(ambiguousOverload.ts, 4, 32), Decl(ambiguousOverload.ts, 6, 39), Decl(ambiguousOverload.ts, 7, 39)) + diff --git a/tests/baselines/reference/ambiguousOverload.types b/tests/baselines/reference/ambiguousOverload.types new file mode 100644 index 00000000000..15fe1e988b8 --- /dev/null +++ b/tests/baselines/reference/ambiguousOverload.types @@ -0,0 +1,59 @@ +=== tests/cases/compiler/ambiguousOverload.ts === +function foof(bar: string, y): number; +>foof : { (bar: string, y: any): number; (bar: string, x: any): string; } +>bar : string +>y : any + +function foof(bar: string, x): string; +>foof : { (bar: string, y: any): number; (bar: string, x: any): string; } +>bar : string +>x : any + +function foof(bar: any): any { return bar }; +>foof : { (bar: string, y: any): number; (bar: string, x: any): string; } +>bar : any +>bar : any + +var x: number = foof("s", null); +>x : number +>foof("s", null) : number +>foof : { (bar: string, y: any): number; (bar: string, x: any): string; } +>"s" : "s" +>null : null + +var y: string = foof("s", null); +>y : string +>foof("s", null) : number +>foof : { (bar: string, y: any): number; (bar: string, x: any): string; } +>"s" : "s" +>null : null + +function foof2(bar: string, x): string; +>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; } +>bar : string +>x : any + +function foof2(bar: string, y): number; +>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; } +>bar : string +>y : any + +function foof2(bar: any): any { return bar }; +>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; } +>bar : any +>bar : any + +var x2: string = foof2("s", null); +>x2 : string +>foof2("s", null) : string +>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; } +>"s" : "s" +>null : null + +var y2: number = foof2("s", null); +>y2 : number +>foof2("s", null) : string +>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; } +>"s" : "s" +>null : null + diff --git a/tests/baselines/reference/amdDependencyComment1.symbols b/tests/baselines/reference/amdDependencyComment1.symbols new file mode 100644 index 00000000000..01502620ab9 --- /dev/null +++ b/tests/baselines/reference/amdDependencyComment1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/amdDependencyComment1.ts === +/// + +import m1 = require("m2") +>m1 : Symbol(m1, Decl(amdDependencyComment1.ts, 0, 0)) + +m1.f(); +>m1 : Symbol(m1, Decl(amdDependencyComment1.ts, 0, 0)) + diff --git a/tests/baselines/reference/amdDependencyComment1.types b/tests/baselines/reference/amdDependencyComment1.types new file mode 100644 index 00000000000..c81dfa5d470 --- /dev/null +++ b/tests/baselines/reference/amdDependencyComment1.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/amdDependencyComment1.ts === +/// + +import m1 = require("m2") +>m1 : any + +m1.f(); +>m1.f() : any +>m1.f : any +>m1 : any +>f : any + diff --git a/tests/baselines/reference/amdDependencyComment2.symbols b/tests/baselines/reference/amdDependencyComment2.symbols new file mode 100644 index 00000000000..0a8fdc9875a --- /dev/null +++ b/tests/baselines/reference/amdDependencyComment2.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/amdDependencyComment2.ts === +/// + +import m1 = require("m2") +>m1 : Symbol(m1, Decl(amdDependencyComment2.ts, 0, 0)) + +m1.f(); +>m1 : Symbol(m1, Decl(amdDependencyComment2.ts, 0, 0)) + diff --git a/tests/baselines/reference/amdDependencyComment2.types b/tests/baselines/reference/amdDependencyComment2.types new file mode 100644 index 00000000000..88e98fb6764 --- /dev/null +++ b/tests/baselines/reference/amdDependencyComment2.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/amdDependencyComment2.ts === +/// + +import m1 = require("m2") +>m1 : any + +m1.f(); +>m1.f() : any +>m1.f : any +>m1 : any +>f : any + diff --git a/tests/baselines/reference/amdDependencyCommentName1.symbols b/tests/baselines/reference/amdDependencyCommentName1.symbols new file mode 100644 index 00000000000..bea7334dd43 --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/amdDependencyCommentName1.ts === +/// + +import m1 = require("m2") +>m1 : Symbol(m1, Decl(amdDependencyCommentName1.ts, 0, 0)) + +m1.f(); +>m1 : Symbol(m1, Decl(amdDependencyCommentName1.ts, 0, 0)) + diff --git a/tests/baselines/reference/amdDependencyCommentName1.types b/tests/baselines/reference/amdDependencyCommentName1.types new file mode 100644 index 00000000000..da083613b79 --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName1.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/amdDependencyCommentName1.ts === +/// + +import m1 = require("m2") +>m1 : any + +m1.f(); +>m1.f() : any +>m1.f : any +>m1 : any +>f : any + diff --git a/tests/baselines/reference/amdDependencyCommentName2.symbols b/tests/baselines/reference/amdDependencyCommentName2.symbols new file mode 100644 index 00000000000..302c9cdb461 --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName2.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/amdDependencyCommentName2.ts === +/// + +import m1 = require("m2") +>m1 : Symbol(m1, Decl(amdDependencyCommentName2.ts, 0, 0)) + +m1.f(); +>m1 : Symbol(m1, Decl(amdDependencyCommentName2.ts, 0, 0)) + diff --git a/tests/baselines/reference/amdDependencyCommentName2.types b/tests/baselines/reference/amdDependencyCommentName2.types new file mode 100644 index 00000000000..a90deec2187 --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName2.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/amdDependencyCommentName2.ts === +/// + +import m1 = require("m2") +>m1 : any + +m1.f(); +>m1.f() : any +>m1.f : any +>m1 : any +>f : any + diff --git a/tests/baselines/reference/amdDependencyCommentName3.symbols b/tests/baselines/reference/amdDependencyCommentName3.symbols new file mode 100644 index 00000000000..43c677c1270 --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName3.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/amdDependencyCommentName3.ts === +/// +/// +/// + +import m1 = require("m2") +>m1 : Symbol(m1, Decl(amdDependencyCommentName3.ts, 0, 0)) + +m1.f(); +>m1 : Symbol(m1, Decl(amdDependencyCommentName3.ts, 0, 0)) + diff --git a/tests/baselines/reference/amdDependencyCommentName3.types b/tests/baselines/reference/amdDependencyCommentName3.types new file mode 100644 index 00000000000..caa6360875d --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName3.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/amdDependencyCommentName3.ts === +/// +/// +/// + +import m1 = require("m2") +>m1 : any + +m1.f(); +>m1.f() : any +>m1.f : any +>m1 : any +>f : any + diff --git a/tests/baselines/reference/amdDependencyCommentName4.symbols b/tests/baselines/reference/amdDependencyCommentName4.symbols new file mode 100644 index 00000000000..5b7e58c8178 --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName4.symbols @@ -0,0 +1,35 @@ +=== tests/cases/compiler/amdDependencyCommentName4.ts === +/// +/// +/// +/// + +import "unaliasedModule1"; + +import r1 = require("aliasedModule1"); +>r1 : Symbol(r1, Decl(amdDependencyCommentName4.ts, 5, 26)) + +r1; +>r1 : Symbol(r1, Decl(amdDependencyCommentName4.ts, 5, 26)) + +import {p1, p2, p3} from "aliasedModule2"; +>p1 : Symbol(p1, Decl(amdDependencyCommentName4.ts, 10, 8)) +>p2 : Symbol(p2, Decl(amdDependencyCommentName4.ts, 10, 11)) +>p3 : Symbol(p3, Decl(amdDependencyCommentName4.ts, 10, 15)) + +p1; +>p1 : Symbol(p1, Decl(amdDependencyCommentName4.ts, 10, 8)) + +import d from "aliasedModule3"; +>d : Symbol(d, Decl(amdDependencyCommentName4.ts, 13, 6)) + +d; +>d : Symbol(d, Decl(amdDependencyCommentName4.ts, 13, 6)) + +import * as ns from "aliasedModule4"; +>ns : Symbol(ns, Decl(amdDependencyCommentName4.ts, 16, 6)) + +ns; +>ns : Symbol(ns, Decl(amdDependencyCommentName4.ts, 16, 6)) + +import "unaliasedModule2"; diff --git a/tests/baselines/reference/amdDependencyCommentName4.types b/tests/baselines/reference/amdDependencyCommentName4.types new file mode 100644 index 00000000000..19042f96d67 --- /dev/null +++ b/tests/baselines/reference/amdDependencyCommentName4.types @@ -0,0 +1,35 @@ +=== tests/cases/compiler/amdDependencyCommentName4.ts === +/// +/// +/// +/// + +import "unaliasedModule1"; + +import r1 = require("aliasedModule1"); +>r1 : any + +r1; +>r1 : any + +import {p1, p2, p3} from "aliasedModule2"; +>p1 : any +>p2 : any +>p3 : any + +p1; +>p1 : any + +import d from "aliasedModule3"; +>d : any + +d; +>d : any + +import * as ns from "aliasedModule4"; +>ns : any + +ns; +>ns : any + +import "unaliasedModule2"; diff --git a/tests/baselines/reference/amdModuleName2.symbols b/tests/baselines/reference/amdModuleName2.symbols new file mode 100644 index 00000000000..48c8e3fbdb4 --- /dev/null +++ b/tests/baselines/reference/amdModuleName2.symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/amdModuleName2.ts === +/// +/// +class Foo { +>Foo : Symbol(Foo, Decl(amdModuleName2.ts, 0, 0)) + + x: number; +>x : Symbol(Foo.x, Decl(amdModuleName2.ts, 2, 11)) + + constructor() { + this.x = 5; +>this.x : Symbol(Foo.x, Decl(amdModuleName2.ts, 2, 11)) +>this : Symbol(Foo, Decl(amdModuleName2.ts, 0, 0)) +>x : Symbol(Foo.x, Decl(amdModuleName2.ts, 2, 11)) + } +} +export = Foo; +>Foo : Symbol(Foo, Decl(amdModuleName2.ts, 0, 0)) + diff --git a/tests/baselines/reference/amdModuleName2.types b/tests/baselines/reference/amdModuleName2.types new file mode 100644 index 00000000000..7989db303ff --- /dev/null +++ b/tests/baselines/reference/amdModuleName2.types @@ -0,0 +1,21 @@ +=== tests/cases/compiler/amdModuleName2.ts === +/// +/// +class Foo { +>Foo : Foo + + x: number; +>x : number + + constructor() { + this.x = 5; +>this.x = 5 : 5 +>this.x : number +>this : this +>x : number +>5 : 5 + } +} +export = Foo; +>Foo : Foo + diff --git a/tests/baselines/reference/anonymousClassExpression2.symbols b/tests/baselines/reference/anonymousClassExpression2.symbols new file mode 100644 index 00000000000..70a193deff7 --- /dev/null +++ b/tests/baselines/reference/anonymousClassExpression2.symbols @@ -0,0 +1,33 @@ +=== tests/cases/compiler/anonymousClassExpression2.ts === +// Fixes #14860 +// note: repros with `while (0);` too +// but it's less inscrutable and more obvious to put it *inside* the loop +while (0) { + class A { +>A : Symbol(A, Decl(anonymousClassExpression2.ts, 3, 11)) + + methodA() { +>methodA : Symbol(A.methodA, Decl(anonymousClassExpression2.ts, 4, 13)) + + this; //note: a this reference of some kind is required to trigger the bug +>this : Symbol(A, Decl(anonymousClassExpression2.ts, 3, 11)) + } + } + + class B { +>B : Symbol(B, Decl(anonymousClassExpression2.ts, 8, 5)) + + methodB() { +>methodB : Symbol(B.methodB, Decl(anonymousClassExpression2.ts, 10, 13)) + + this.methodA; // error +>this : Symbol(B, Decl(anonymousClassExpression2.ts, 8, 5)) + + this.methodB; // ok +>this.methodB : Symbol(B.methodB, Decl(anonymousClassExpression2.ts, 10, 13)) +>this : Symbol(B, Decl(anonymousClassExpression2.ts, 8, 5)) +>methodB : Symbol(B.methodB, Decl(anonymousClassExpression2.ts, 10, 13)) + } + } +} + diff --git a/tests/baselines/reference/anonymousClassExpression2.types b/tests/baselines/reference/anonymousClassExpression2.types new file mode 100644 index 00000000000..f26f8e497ca --- /dev/null +++ b/tests/baselines/reference/anonymousClassExpression2.types @@ -0,0 +1,37 @@ +=== tests/cases/compiler/anonymousClassExpression2.ts === +// Fixes #14860 +// note: repros with `while (0);` too +// but it's less inscrutable and more obvious to put it *inside* the loop +while (0) { +>0 : 0 + + class A { +>A : A + + methodA() { +>methodA : () => void + + this; //note: a this reference of some kind is required to trigger the bug +>this : this + } + } + + class B { +>B : B + + methodB() { +>methodB : () => void + + this.methodA; // error +>this.methodA : any +>this : this +>methodA : any + + this.methodB; // ok +>this.methodB : () => void +>this : this +>methodB : () => void + } + } +} + diff --git a/tests/baselines/reference/anonymousModules.symbols b/tests/baselines/reference/anonymousModules.symbols new file mode 100644 index 00000000000..1967e246648 --- /dev/null +++ b/tests/baselines/reference/anonymousModules.symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/anonymousModules.ts === +module { + export var foo = 1; +>foo : Symbol(foo, Decl(anonymousModules.ts, 1, 11)) + + module { + export var bar = 1; +>bar : Symbol(bar, Decl(anonymousModules.ts, 4, 12), Decl(anonymousModules.ts, 7, 4)) + } + + var bar = 2; +>bar : Symbol(bar, Decl(anonymousModules.ts, 4, 12), Decl(anonymousModules.ts, 7, 4)) + + module { + var x = bar; +>x : Symbol(x, Decl(anonymousModules.ts, 10, 5)) +>bar : Symbol(bar, Decl(anonymousModules.ts, 4, 12), Decl(anonymousModules.ts, 7, 4)) + } +} diff --git a/tests/baselines/reference/anonymousModules.types b/tests/baselines/reference/anonymousModules.types new file mode 100644 index 00000000000..d06ff96ba37 --- /dev/null +++ b/tests/baselines/reference/anonymousModules.types @@ -0,0 +1,28 @@ +=== tests/cases/compiler/anonymousModules.ts === +module { +>module : any + + export var foo = 1; +>foo : number +>1 : 1 + + module { +>module : any + + export var bar = 1; +>bar : number +>1 : 1 + } + + var bar = 2; +>bar : number +>2 : 2 + + module { +>module : any + + var x = bar; +>x : number +>bar : number + } +} diff --git a/tests/baselines/reference/anyAsConstructor.symbols b/tests/baselines/reference/anyAsConstructor.symbols new file mode 100644 index 00000000000..440d77730da --- /dev/null +++ b/tests/baselines/reference/anyAsConstructor.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/types/any/anyAsConstructor.ts === +// any is considered an untyped function call +// can be called except with type arguments which is an error + +var x: any; +>x : Symbol(x, Decl(anyAsConstructor.ts, 3, 3)) + +var a = new x(); +>a : Symbol(a, Decl(anyAsConstructor.ts, 4, 3)) +>x : Symbol(x, Decl(anyAsConstructor.ts, 3, 3)) + +var b = new x('hello'); +>b : Symbol(b, Decl(anyAsConstructor.ts, 5, 3)) +>x : Symbol(x, Decl(anyAsConstructor.ts, 3, 3)) + +var c = new x(x); +>c : Symbol(c, Decl(anyAsConstructor.ts, 6, 3)) +>x : Symbol(x, Decl(anyAsConstructor.ts, 3, 3)) +>x : Symbol(x, Decl(anyAsConstructor.ts, 3, 3)) + +// grammar allows this for constructors +var d = new x(x); // no error +>d : Symbol(d, Decl(anyAsConstructor.ts, 9, 3)) +>x : Symbol(x, Decl(anyAsConstructor.ts, 3, 3)) +>x : Symbol(x, Decl(anyAsConstructor.ts, 3, 3)) + diff --git a/tests/baselines/reference/anyAsConstructor.types b/tests/baselines/reference/anyAsConstructor.types new file mode 100644 index 00000000000..56ae4315b75 --- /dev/null +++ b/tests/baselines/reference/anyAsConstructor.types @@ -0,0 +1,31 @@ +=== tests/cases/conformance/types/any/anyAsConstructor.ts === +// any is considered an untyped function call +// can be called except with type arguments which is an error + +var x: any; +>x : any + +var a = new x(); +>a : any +>new x() : any +>x : any + +var b = new x('hello'); +>b : any +>new x('hello') : any +>x : any +>'hello' : "hello" + +var c = new x(x); +>c : any +>new x(x) : any +>x : any +>x : any + +// grammar allows this for constructors +var d = new x(x); // no error +>d : any +>new x(x) : any +>x : any +>x : any + diff --git a/tests/baselines/reference/anyAsGenericFunctionCall.symbols b/tests/baselines/reference/anyAsGenericFunctionCall.symbols new file mode 100644 index 00000000000..be29f1def44 --- /dev/null +++ b/tests/baselines/reference/anyAsGenericFunctionCall.symbols @@ -0,0 +1,30 @@ +=== tests/cases/conformance/types/any/anyAsGenericFunctionCall.ts === +// any is considered an untyped function call +// can be called except with type arguments which is an error + +var x: any; +>x : Symbol(x, Decl(anyAsGenericFunctionCall.ts, 3, 3)) + +var a = x(); +>a : Symbol(a, Decl(anyAsGenericFunctionCall.ts, 4, 3)) +>x : Symbol(x, Decl(anyAsGenericFunctionCall.ts, 3, 3)) + +var b = x('hello'); +>b : Symbol(b, Decl(anyAsGenericFunctionCall.ts, 5, 3)) +>x : Symbol(x, Decl(anyAsGenericFunctionCall.ts, 3, 3)) + +class C { foo: string; } +>C : Symbol(C, Decl(anyAsGenericFunctionCall.ts, 5, 27)) +>foo : Symbol(C.foo, Decl(anyAsGenericFunctionCall.ts, 7, 9)) + +var c = x(x); +>c : Symbol(c, Decl(anyAsGenericFunctionCall.ts, 8, 3)) +>x : Symbol(x, Decl(anyAsGenericFunctionCall.ts, 3, 3)) +>C : Symbol(C, Decl(anyAsGenericFunctionCall.ts, 5, 27)) +>x : Symbol(x, Decl(anyAsGenericFunctionCall.ts, 3, 3)) + +var d = x(x); +>d : Symbol(d, Decl(anyAsGenericFunctionCall.ts, 9, 3)) +>x : Symbol(x, Decl(anyAsGenericFunctionCall.ts, 3, 3)) +>x : Symbol(x, Decl(anyAsGenericFunctionCall.ts, 3, 3)) + diff --git a/tests/baselines/reference/anyAsGenericFunctionCall.types b/tests/baselines/reference/anyAsGenericFunctionCall.types new file mode 100644 index 00000000000..4cf5dd8990d --- /dev/null +++ b/tests/baselines/reference/anyAsGenericFunctionCall.types @@ -0,0 +1,35 @@ +=== tests/cases/conformance/types/any/anyAsGenericFunctionCall.ts === +// any is considered an untyped function call +// can be called except with type arguments which is an error + +var x: any; +>x : any + +var a = x(); +>a : any +>x() : any +>x : any + +var b = x('hello'); +>b : any +>x('hello') : any +>x : any +>'hello' : "hello" + +class C { foo: string; } +>C : C +>foo : string + +var c = x(x); +>c : any +>x(x) : any +>x : any +>C : C +>x : any + +var d = x(x); +>d : any +>x(x) : any +>x : any +>x : any + diff --git a/tests/baselines/reference/anyAssignabilityInInheritance.symbols b/tests/baselines/reference/anyAssignabilityInInheritance.symbols index d1043256962..56bb982fea1 100644 --- a/tests/baselines/reference/anyAssignabilityInInheritance.symbols +++ b/tests/baselines/reference/anyAssignabilityInInheritance.symbols @@ -23,7 +23,7 @@ declare function foo2(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 10, 22)) var r3 = foo2(a); // any, not a subtype of number so it skips that overload, is a subtype of itself so it picks second (if truly ambiguous it would pick first overload) ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo2 : Symbol(foo2, Decl(anyAssignabilityInInheritance.ts, 7, 11), Decl(anyAssignabilityInInheritance.ts, 9, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -36,7 +36,7 @@ declare function foo3(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 14, 22)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -49,7 +49,7 @@ declare function foo4(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 18, 22)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -64,7 +64,7 @@ declare function foo5(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 22, 22)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -79,7 +79,7 @@ declare function foo6(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 26, 22)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -94,7 +94,7 @@ declare function foo7(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 30, 22)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -107,7 +107,7 @@ declare function foo8(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 34, 22)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -126,7 +126,7 @@ declare function foo9(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 39, 22)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -145,7 +145,7 @@ declare function foo10(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 44, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -166,7 +166,7 @@ declare function foo11(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 49, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -181,7 +181,7 @@ declare function foo12(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 53, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -202,7 +202,7 @@ declare function foo13(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 57, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -221,7 +221,7 @@ declare function foo14(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 62, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -245,7 +245,7 @@ declare function foo15(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 70, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -270,7 +270,7 @@ declare function foo16(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 78, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -285,7 +285,7 @@ declare function foo17(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 82, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) @@ -298,7 +298,7 @@ declare function foo18(x: any): any; >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 86, 23)) var r3 = foo3(a); // any ->r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3), Decl(anyAssignabilityInInheritance.ts, 31, 3), Decl(anyAssignabilityInInheritance.ts, 35, 3), Decl(anyAssignabilityInInheritance.ts, 40, 3), Decl(anyAssignabilityInInheritance.ts, 45, 3), Decl(anyAssignabilityInInheritance.ts, 50, 3), Decl(anyAssignabilityInInheritance.ts, 54, 3), Decl(anyAssignabilityInInheritance.ts, 58, 3), Decl(anyAssignabilityInInheritance.ts, 63, 3), Decl(anyAssignabilityInInheritance.ts, 71, 3), Decl(anyAssignabilityInInheritance.ts, 79, 3), Decl(anyAssignabilityInInheritance.ts, 83, 3), Decl(anyAssignabilityInInheritance.ts, 87, 3)) +>r3 : Symbol(r3, Decl(anyAssignabilityInInheritance.ts, 11, 3), Decl(anyAssignabilityInInheritance.ts, 15, 3), Decl(anyAssignabilityInInheritance.ts, 19, 3), Decl(anyAssignabilityInInheritance.ts, 23, 3), Decl(anyAssignabilityInInheritance.ts, 27, 3) ... and 12 more) >foo3 : Symbol(foo3, Decl(anyAssignabilityInInheritance.ts, 11, 17), Decl(anyAssignabilityInInheritance.ts, 13, 41)) >a : Symbol(a, Decl(anyAssignabilityInInheritance.ts, 7, 3)) diff --git a/tests/baselines/reference/anyDeclare.symbols b/tests/baselines/reference/anyDeclare.symbols new file mode 100644 index 00000000000..8975677a7c2 --- /dev/null +++ b/tests/baselines/reference/anyDeclare.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/anyDeclare.ts === +declare var x: any; +>x : Symbol(x, Decl(anyDeclare.ts, 0, 11)) + +module myMod { +>myMod : Symbol(myMod, Decl(anyDeclare.ts, 0, 19)) + + var myFn; +>myFn : Symbol(myFn, Decl(anyDeclare.ts, 2, 7)) + + function myFn() { } +>myFn : Symbol(myFn, Decl(anyDeclare.ts, 2, 13)) +} + diff --git a/tests/baselines/reference/anyDeclare.types b/tests/baselines/reference/anyDeclare.types new file mode 100644 index 00000000000..6d1e85a4ae8 --- /dev/null +++ b/tests/baselines/reference/anyDeclare.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/anyDeclare.ts === +declare var x: any; +>x : any + +module myMod { +>myMod : typeof myMod + + var myFn; +>myFn : any + + function myFn() { } +>myFn : () => void +} + diff --git a/tests/baselines/reference/anyIdenticalToItself.symbols b/tests/baselines/reference/anyIdenticalToItself.symbols new file mode 100644 index 00000000000..f09459d6bfc --- /dev/null +++ b/tests/baselines/reference/anyIdenticalToItself.symbols @@ -0,0 +1,31 @@ +=== tests/cases/compiler/anyIdenticalToItself.ts === +function foo(x: any); +>foo : Symbol(foo, Decl(anyIdenticalToItself.ts, 0, 0), Decl(anyIdenticalToItself.ts, 0, 21), Decl(anyIdenticalToItself.ts, 1, 21)) +>x : Symbol(x, Decl(anyIdenticalToItself.ts, 0, 13)) + +function foo(x: any); +>foo : Symbol(foo, Decl(anyIdenticalToItself.ts, 0, 0), Decl(anyIdenticalToItself.ts, 0, 21), Decl(anyIdenticalToItself.ts, 1, 21)) +>x : Symbol(x, Decl(anyIdenticalToItself.ts, 1, 13)) + +function foo(x: any, y: number) { } +>foo : Symbol(foo, Decl(anyIdenticalToItself.ts, 0, 0), Decl(anyIdenticalToItself.ts, 0, 21), Decl(anyIdenticalToItself.ts, 1, 21)) +>x : Symbol(x, Decl(anyIdenticalToItself.ts, 2, 13)) +>y : Symbol(y, Decl(anyIdenticalToItself.ts, 2, 20)) + +class C { +>C : Symbol(C, Decl(anyIdenticalToItself.ts, 2, 35)) + + get X(): any { +>X : Symbol(C.X, Decl(anyIdenticalToItself.ts, 4, 9), Decl(anyIdenticalToItself.ts, 8, 5)) + + var y: any; +>y : Symbol(y, Decl(anyIdenticalToItself.ts, 6, 11)) + + return y; +>y : Symbol(y, Decl(anyIdenticalToItself.ts, 6, 11)) + } + set X(v: any) { +>X : Symbol(C.X, Decl(anyIdenticalToItself.ts, 4, 9), Decl(anyIdenticalToItself.ts, 8, 5)) +>v : Symbol(v, Decl(anyIdenticalToItself.ts, 9, 10)) + } +} diff --git a/tests/baselines/reference/anyIdenticalToItself.types b/tests/baselines/reference/anyIdenticalToItself.types new file mode 100644 index 00000000000..fa71f579cbb --- /dev/null +++ b/tests/baselines/reference/anyIdenticalToItself.types @@ -0,0 +1,31 @@ +=== tests/cases/compiler/anyIdenticalToItself.ts === +function foo(x: any); +>foo : { (x: any): any; (x: any): any; } +>x : any + +function foo(x: any); +>foo : { (x: any): any; (x: any): any; } +>x : any + +function foo(x: any, y: number) { } +>foo : { (x: any): any; (x: any): any; } +>x : any +>y : number + +class C { +>C : C + + get X(): any { +>X : any + + var y: any; +>y : any + + return y; +>y : any + } + set X(v: any) { +>X : any +>v : any + } +} diff --git a/tests/baselines/reference/anyIndexedAccessArrayNoException.symbols b/tests/baselines/reference/anyIndexedAccessArrayNoException.symbols new file mode 100644 index 00000000000..31e706cb8cd --- /dev/null +++ b/tests/baselines/reference/anyIndexedAccessArrayNoException.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/anyIndexedAccessArrayNoException.ts === +var x: any[[]]; +>x : Symbol(x, Decl(anyIndexedAccessArrayNoException.ts, 0, 3)) + diff --git a/tests/baselines/reference/anyIndexedAccessArrayNoException.types b/tests/baselines/reference/anyIndexedAccessArrayNoException.types new file mode 100644 index 00000000000..b915911ca61 --- /dev/null +++ b/tests/baselines/reference/anyIndexedAccessArrayNoException.types @@ -0,0 +1,4 @@ +=== tests/cases/compiler/anyIndexedAccessArrayNoException.ts === +var x: any[[]]; +>x : any + diff --git a/tests/baselines/reference/apparentTypeSubtyping.symbols b/tests/baselines/reference/apparentTypeSubtyping.symbols new file mode 100644 index 00000000000..dae469bfc9a --- /dev/null +++ b/tests/baselines/reference/apparentTypeSubtyping.symbols @@ -0,0 +1,48 @@ +=== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtyping.ts === +// subtype checks use the apparent type of the target type +// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S: + +class Base { +>Base : Symbol(Base, Decl(apparentTypeSubtyping.ts, 0, 0)) +>U : Symbol(U, Decl(apparentTypeSubtyping.ts, 3, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + x: U; +>x : Symbol(Base.x, Decl(apparentTypeSubtyping.ts, 3, 30)) +>U : Symbol(U, Decl(apparentTypeSubtyping.ts, 3, 11)) +} + +// is String (S) a subtype of U extends String (T)? Would only be true if we used the apparent type of U (T) +class Derived extends Base { // error +>Derived : Symbol(Derived, Decl(apparentTypeSubtyping.ts, 5, 1)) +>U : Symbol(U, Decl(apparentTypeSubtyping.ts, 8, 14)) +>Base : Symbol(Base, Decl(apparentTypeSubtyping.ts, 0, 0)) + + x: String; +>x : Symbol(Derived.x, Decl(apparentTypeSubtyping.ts, 8, 39)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +} + +class Base2 { +>Base2 : Symbol(Base2, Decl(apparentTypeSubtyping.ts, 10, 1)) + + x: String; +>x : Symbol(Base2.x, Decl(apparentTypeSubtyping.ts, 12, 13)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + static s: String; +>s : Symbol(Base2.s, Decl(apparentTypeSubtyping.ts, 13, 14)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +} + +// is U extends String (S) a subtype of String (T)? Apparent type of U is String so it succeeds +class Derived2 extends Base2 { // error because of the prototype's not matching, not because of the instance side +>Derived2 : Symbol(Derived2, Decl(apparentTypeSubtyping.ts, 15, 1)) +>U : Symbol(U, Decl(apparentTypeSubtyping.ts, 18, 15)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base2 : Symbol(Base2, Decl(apparentTypeSubtyping.ts, 10, 1)) + + x: U; +>x : Symbol(Derived2.x, Decl(apparentTypeSubtyping.ts, 18, 48)) +>U : Symbol(U, Decl(apparentTypeSubtyping.ts, 18, 15)) +} diff --git a/tests/baselines/reference/apparentTypeSubtyping.types b/tests/baselines/reference/apparentTypeSubtyping.types new file mode 100644 index 00000000000..7eba6ac5941 --- /dev/null +++ b/tests/baselines/reference/apparentTypeSubtyping.types @@ -0,0 +1,48 @@ +=== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtyping.ts === +// subtype checks use the apparent type of the target type +// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S: + +class Base { +>Base : Base +>U : U +>String : String + + x: U; +>x : U +>U : U +} + +// is String (S) a subtype of U extends String (T)? Would only be true if we used the apparent type of U (T) +class Derived extends Base { // error +>Derived : Derived +>U : U +>Base : Base + + x: String; +>x : String +>String : String +} + +class Base2 { +>Base2 : Base2 + + x: String; +>x : String +>String : String + + static s: String; +>s : String +>String : String +} + +// is U extends String (S) a subtype of String (T)? Apparent type of U is String so it succeeds +class Derived2 extends Base2 { // error because of the prototype's not matching, not because of the instance side +>Derived2 : Derived2 +>U : U +>String : String +>Base2 : Base2 + + x: U; +>x : U +>U : U +} diff --git a/tests/baselines/reference/apparentTypeSupertype.symbols b/tests/baselines/reference/apparentTypeSupertype.symbols new file mode 100644 index 00000000000..d572fae2ca7 --- /dev/null +++ b/tests/baselines/reference/apparentTypeSupertype.symbols @@ -0,0 +1,22 @@ +=== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSupertype.ts === +// subtype checks use the apparent type of the target type +// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S: + +class Base { +>Base : Symbol(Base, Decl(apparentTypeSupertype.ts, 0, 0)) + + x: string; +>x : Symbol(Base.x, Decl(apparentTypeSupertype.ts, 3, 12)) +} + +// is String (S) a subtype of U extends String (T)? Would only be true if we used the apparent type of U (T) +class Derived extends Base { // error +>Derived : Symbol(Derived, Decl(apparentTypeSupertype.ts, 5, 1)) +>U : Symbol(U, Decl(apparentTypeSupertype.ts, 8, 14)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(apparentTypeSupertype.ts, 0, 0)) + + x: U; +>x : Symbol(Derived.x, Decl(apparentTypeSupertype.ts, 8, 46)) +>U : Symbol(U, Decl(apparentTypeSupertype.ts, 8, 14)) +} diff --git a/tests/baselines/reference/apparentTypeSupertype.types b/tests/baselines/reference/apparentTypeSupertype.types new file mode 100644 index 00000000000..626a4c0632d --- /dev/null +++ b/tests/baselines/reference/apparentTypeSupertype.types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSupertype.ts === +// subtype checks use the apparent type of the target type +// S is a subtype of a type T, and T is a supertype of S, if one of the following is true, where S' denotes the apparent type (section 3.8.1) of S: + +class Base { +>Base : Base + + x: string; +>x : string +} + +// is String (S) a subtype of U extends String (T)? Would only be true if we used the apparent type of U (T) +class Derived extends Base { // error +>Derived : Derived +>U : U +>String : String +>Base : Base + + x: U; +>x : U +>U : U +} diff --git a/tests/baselines/reference/argumentExpressionContextualTyping.symbols b/tests/baselines/reference/argumentExpressionContextualTyping.symbols new file mode 100644 index 00000000000..9ed7d130795 --- /dev/null +++ b/tests/baselines/reference/argumentExpressionContextualTyping.symbols @@ -0,0 +1,85 @@ +=== tests/cases/conformance/expressions/contextualTyping/argumentExpressionContextualTyping.ts === +// In a typed function call, argument expressions are contextually typed by their corresponding parameter types. +function foo({x: [a, b], y: {c, d, e}}) { } +>foo : Symbol(foo, Decl(argumentExpressionContextualTyping.ts, 0, 0)) +>x : Symbol(x) +>a : Symbol(a, Decl(argumentExpressionContextualTyping.ts, 1, 18)) +>b : Symbol(b, Decl(argumentExpressionContextualTyping.ts, 1, 20)) +>y : Symbol(y) +>c : Symbol(c, Decl(argumentExpressionContextualTyping.ts, 1, 29)) +>d : Symbol(d, Decl(argumentExpressionContextualTyping.ts, 1, 31)) +>e : Symbol(e, Decl(argumentExpressionContextualTyping.ts, 1, 34)) + +function bar({x: [a, b = 10], y: {c, d, e = { f:1 }}}) { } +>bar : Symbol(bar, Decl(argumentExpressionContextualTyping.ts, 1, 43)) +>x : Symbol(x) +>a : Symbol(a, Decl(argumentExpressionContextualTyping.ts, 2, 18)) +>b : Symbol(b, Decl(argumentExpressionContextualTyping.ts, 2, 20)) +>y : Symbol(y) +>c : Symbol(c, Decl(argumentExpressionContextualTyping.ts, 2, 34)) +>d : Symbol(d, Decl(argumentExpressionContextualTyping.ts, 2, 36)) +>e : Symbol(e, Decl(argumentExpressionContextualTyping.ts, 2, 39)) +>f : Symbol(f, Decl(argumentExpressionContextualTyping.ts, 2, 45)) + +function baz(x: [string, number, boolean]) { } +>baz : Symbol(baz, Decl(argumentExpressionContextualTyping.ts, 2, 58)) +>x : Symbol(x, Decl(argumentExpressionContextualTyping.ts, 3, 13)) + +var o = { x: ["string", 1], y: { c: true, d: "world", e: 3 } }; +>o : Symbol(o, Decl(argumentExpressionContextualTyping.ts, 5, 3)) +>x : Symbol(x, Decl(argumentExpressionContextualTyping.ts, 5, 9)) +>y : Symbol(y, Decl(argumentExpressionContextualTyping.ts, 5, 27)) +>c : Symbol(c, Decl(argumentExpressionContextualTyping.ts, 5, 32)) +>d : Symbol(d, Decl(argumentExpressionContextualTyping.ts, 5, 41)) +>e : Symbol(e, Decl(argumentExpressionContextualTyping.ts, 5, 53)) + +var o1: { x: [string, number], y: { c: boolean, d: string, e: number } } = { x: ["string", 1], y: { c: true, d: "world", e: 3 } }; +>o1 : Symbol(o1, Decl(argumentExpressionContextualTyping.ts, 6, 3)) +>x : Symbol(x, Decl(argumentExpressionContextualTyping.ts, 6, 9)) +>y : Symbol(y, Decl(argumentExpressionContextualTyping.ts, 6, 30)) +>c : Symbol(c, Decl(argumentExpressionContextualTyping.ts, 6, 35)) +>d : Symbol(d, Decl(argumentExpressionContextualTyping.ts, 6, 47)) +>e : Symbol(e, Decl(argumentExpressionContextualTyping.ts, 6, 58)) +>x : Symbol(x, Decl(argumentExpressionContextualTyping.ts, 6, 76)) +>y : Symbol(y, Decl(argumentExpressionContextualTyping.ts, 6, 94)) +>c : Symbol(c, Decl(argumentExpressionContextualTyping.ts, 6, 99)) +>d : Symbol(d, Decl(argumentExpressionContextualTyping.ts, 6, 108)) +>e : Symbol(e, Decl(argumentExpressionContextualTyping.ts, 6, 120)) + +foo(o1); // Not error since x has contextual type of tuple namely [string, number] +>foo : Symbol(foo, Decl(argumentExpressionContextualTyping.ts, 0, 0)) +>o1 : Symbol(o1, Decl(argumentExpressionContextualTyping.ts, 6, 3)) + +foo({ x: ["string", 1], y: { c: true, d: "world", e: 3 } }); // Not error +>foo : Symbol(foo, Decl(argumentExpressionContextualTyping.ts, 0, 0)) +>x : Symbol(x, Decl(argumentExpressionContextualTyping.ts, 8, 5)) +>y : Symbol(y, Decl(argumentExpressionContextualTyping.ts, 8, 23)) +>c : Symbol(c, Decl(argumentExpressionContextualTyping.ts, 8, 28)) +>d : Symbol(d, Decl(argumentExpressionContextualTyping.ts, 8, 37)) +>e : Symbol(e, Decl(argumentExpressionContextualTyping.ts, 8, 49)) + +var array = ["string", 1, true]; +>array : Symbol(array, Decl(argumentExpressionContextualTyping.ts, 10, 3)) + +var tuple: [string, number, boolean] = ["string", 1, true]; +>tuple : Symbol(tuple, Decl(argumentExpressionContextualTyping.ts, 11, 3)) + +baz(tuple); +>baz : Symbol(baz, Decl(argumentExpressionContextualTyping.ts, 2, 58)) +>tuple : Symbol(tuple, Decl(argumentExpressionContextualTyping.ts, 11, 3)) + +baz(["string", 1, true]); +>baz : Symbol(baz, Decl(argumentExpressionContextualTyping.ts, 2, 58)) + +baz(array); // Error +>baz : Symbol(baz, Decl(argumentExpressionContextualTyping.ts, 2, 58)) +>array : Symbol(array, Decl(argumentExpressionContextualTyping.ts, 10, 3)) + +baz(["string", 1, true, ...array]); // Error +>baz : Symbol(baz, Decl(argumentExpressionContextualTyping.ts, 2, 58)) +>array : Symbol(array, Decl(argumentExpressionContextualTyping.ts, 10, 3)) + +foo(o); // Error because x has an array type namely (string|number)[] +>foo : Symbol(foo, Decl(argumentExpressionContextualTyping.ts, 0, 0)) +>o : Symbol(o, Decl(argumentExpressionContextualTyping.ts, 5, 3)) + diff --git a/tests/baselines/reference/argumentExpressionContextualTyping.types b/tests/baselines/reference/argumentExpressionContextualTyping.types new file mode 100644 index 00000000000..3b0fec11aa2 --- /dev/null +++ b/tests/baselines/reference/argumentExpressionContextualTyping.types @@ -0,0 +1,136 @@ +=== tests/cases/conformance/expressions/contextualTyping/argumentExpressionContextualTyping.ts === +// In a typed function call, argument expressions are contextually typed by their corresponding parameter types. +function foo({x: [a, b], y: {c, d, e}}) { } +>foo : ({ x: [a, b], y: { c, d, e } }: { x: [any, any]; y: { c: any; d: any; e: any; }; }) => void +>x : any +>a : any +>b : any +>y : any +>c : any +>d : any +>e : any + +function bar({x: [a, b = 10], y: {c, d, e = { f:1 }}}) { } +>bar : ({ x: [a, b], y: { c, d, e } }: { x: [any, number]; y: { c: any; d: any; e?: { f: number; }; }; }) => void +>x : any +>a : any +>b : number +>10 : 10 +>y : any +>c : any +>d : any +>e : { f: number; } +>{ f:1 } : { f: number; } +>f : number +>1 : 1 + +function baz(x: [string, number, boolean]) { } +>baz : (x: [string, number, boolean]) => void +>x : [string, number, boolean] + +var o = { x: ["string", 1], y: { c: true, d: "world", e: 3 } }; +>o : { x: (string | number)[]; y: { c: boolean; d: string; e: number; }; } +>{ x: ["string", 1], y: { c: true, d: "world", e: 3 } } : { x: (string | number)[]; y: { c: boolean; d: string; e: number; }; } +>x : (string | number)[] +>["string", 1] : (string | number)[] +>"string" : "string" +>1 : 1 +>y : { c: boolean; d: string; e: number; } +>{ c: true, d: "world", e: 3 } : { c: boolean; d: string; e: number; } +>c : boolean +>true : true +>d : string +>"world" : "world" +>e : number +>3 : 3 + +var o1: { x: [string, number], y: { c: boolean, d: string, e: number } } = { x: ["string", 1], y: { c: true, d: "world", e: 3 } }; +>o1 : { x: [string, number]; y: { c: boolean; d: string; e: number; }; } +>x : [string, number] +>y : { c: boolean; d: string; e: number; } +>c : boolean +>d : string +>e : number +>{ x: ["string", 1], y: { c: true, d: "world", e: 3 } } : { x: [string, number]; y: { c: true; d: string; e: number; }; } +>x : [string, number] +>["string", 1] : [string, number] +>"string" : "string" +>1 : 1 +>y : { c: true; d: string; e: number; } +>{ c: true, d: "world", e: 3 } : { c: true; d: string; e: number; } +>c : boolean +>true : true +>d : string +>"world" : "world" +>e : number +>3 : 3 + +foo(o1); // Not error since x has contextual type of tuple namely [string, number] +>foo(o1) : void +>foo : ({ x: [a, b], y: { c, d, e } }: { x: [any, any]; y: { c: any; d: any; e: any; }; }) => void +>o1 : { x: [string, number]; y: { c: boolean; d: string; e: number; }; } + +foo({ x: ["string", 1], y: { c: true, d: "world", e: 3 } }); // Not error +>foo({ x: ["string", 1], y: { c: true, d: "world", e: 3 } }) : void +>foo : ({ x: [a, b], y: { c, d, e } }: { x: [any, any]; y: { c: any; d: any; e: any; }; }) => void +>{ x: ["string", 1], y: { c: true, d: "world", e: 3 } } : { x: [string, number]; y: { c: boolean; d: string; e: number; }; } +>x : [string, number] +>["string", 1] : [string, number] +>"string" : "string" +>1 : 1 +>y : { c: boolean; d: string; e: number; } +>{ c: true, d: "world", e: 3 } : { c: boolean; d: string; e: number; } +>c : boolean +>true : true +>d : string +>"world" : "world" +>e : number +>3 : 3 + +var array = ["string", 1, true]; +>array : (string | number | boolean)[] +>["string", 1, true] : (string | number | boolean)[] +>"string" : "string" +>1 : 1 +>true : true + +var tuple: [string, number, boolean] = ["string", 1, true]; +>tuple : [string, number, boolean] +>["string", 1, true] : [string, number, true] +>"string" : "string" +>1 : 1 +>true : true + +baz(tuple); +>baz(tuple) : void +>baz : (x: [string, number, boolean]) => void +>tuple : [string, number, boolean] + +baz(["string", 1, true]); +>baz(["string", 1, true]) : void +>baz : (x: [string, number, boolean]) => void +>["string", 1, true] : [string, number, true] +>"string" : "string" +>1 : 1 +>true : true + +baz(array); // Error +>baz(array) : void +>baz : (x: [string, number, boolean]) => void +>array : (string | number | boolean)[] + +baz(["string", 1, true, ...array]); // Error +>baz(["string", 1, true, ...array]) : void +>baz : (x: [string, number, boolean]) => void +>["string", 1, true, ...array] : (string | number | boolean)[] +>"string" : "string" +>1 : 1 +>true : true +>...array : string | number | boolean +>array : (string | number | boolean)[] + +foo(o); // Error because x has an array type namely (string|number)[] +>foo(o) : void +>foo : ({ x: [a, b], y: { c, d, e } }: { x: [any, any]; y: { c: any; d: any; e: any; }; }) => void +>o : { x: (string | number)[]; y: { c: boolean; d: string; e: number; }; } + diff --git a/tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.symbols b/tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.symbols new file mode 100644 index 00000000000..f8741f53c84 --- /dev/null +++ b/tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/argumentsBindsToFunctionScopeArgumentList.ts === +var arguments = 10; +>arguments : Symbol(arguments, Decl(argumentsBindsToFunctionScopeArgumentList.ts, 0, 3)) + +function foo(a) { +>foo : Symbol(foo, Decl(argumentsBindsToFunctionScopeArgumentList.ts, 0, 19)) +>a : Symbol(a, Decl(argumentsBindsToFunctionScopeArgumentList.ts, 1, 13)) + + arguments = 10; /// This shouldnt be of type number and result in error. +>arguments : Symbol(arguments) +} diff --git a/tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.types b/tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.types new file mode 100644 index 00000000000..4aecd3bc4be --- /dev/null +++ b/tests/baselines/reference/argumentsBindsToFunctionScopeArgumentList.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/argumentsBindsToFunctionScopeArgumentList.ts === +var arguments = 10; +>arguments : number +>10 : 10 + +function foo(a) { +>foo : (a: any) => void +>a : any + + arguments = 10; /// This shouldnt be of type number and result in error. +>arguments = 10 : 10 +>arguments : IArguments +>10 : 10 +} diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.symbols b/tests/baselines/reference/argumentsObjectIterator01_ES5.symbols new file mode 100644 index 00000000000..7eb2736b3ea --- /dev/null +++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.symbols @@ -0,0 +1,24 @@ +=== tests/cases/compiler/argumentsObjectIterator01_ES5.ts === +function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { +>doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator01_ES5.ts, 0, 0)) +>x : Symbol(x, Decl(argumentsObjectIterator01_ES5.ts, 0, 32)) +>y : Symbol(y, Decl(argumentsObjectIterator01_ES5.ts, 0, 42)) +>z : Symbol(z, Decl(argumentsObjectIterator01_ES5.ts, 0, 53)) + + let result = []; +>result : Symbol(result, Decl(argumentsObjectIterator01_ES5.ts, 1, 7)) + + for (let arg of arguments) { +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES5.ts, 2, 12)) +>arguments : Symbol(arguments) + + result.push(arg + arg); +>result.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) +>result : Symbol(result, Decl(argumentsObjectIterator01_ES5.ts, 1, 7)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES5.ts, 2, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator01_ES5.ts, 2, 12)) + } + return <[any, any, any]>result; +>result : Symbol(result, Decl(argumentsObjectIterator01_ES5.ts, 1, 7)) +} diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.types b/tests/baselines/reference/argumentsObjectIterator01_ES5.types new file mode 100644 index 00000000000..60ca2090880 --- /dev/null +++ b/tests/baselines/reference/argumentsObjectIterator01_ES5.types @@ -0,0 +1,28 @@ +=== tests/cases/compiler/argumentsObjectIterator01_ES5.ts === +function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { +>doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number] +>x : number +>y : number +>z : number + + let result = []; +>result : any[] +>[] : undefined[] + + for (let arg of arguments) { +>arg : any +>arguments : IArguments + + result.push(arg + arg); +>result.push(arg + arg) : number +>result.push : (...items: any[]) => number +>result : any[] +>push : (...items: any[]) => number +>arg + arg : any +>arg : any +>arg : any + } + return <[any, any, any]>result; +><[any, any, any]>result : [any, any, any] +>result : any[] +} diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES5.symbols new file mode 100644 index 00000000000..0e1af3a76ad --- /dev/null +++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/argumentsObjectIterator02_ES5.ts === +function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { +>doubleAndReturnAsArray : Symbol(doubleAndReturnAsArray, Decl(argumentsObjectIterator02_ES5.ts, 0, 0)) +>x : Symbol(x, Decl(argumentsObjectIterator02_ES5.ts, 0, 32)) +>y : Symbol(y, Decl(argumentsObjectIterator02_ES5.ts, 0, 42)) +>z : Symbol(z, Decl(argumentsObjectIterator02_ES5.ts, 0, 53)) + + let blah = arguments[Symbol.iterator]; +>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES5.ts, 1, 7)) +>arguments : Symbol(arguments) + + let result = []; +>result : Symbol(result, Decl(argumentsObjectIterator02_ES5.ts, 3, 7)) + + for (let arg of blah()) { +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES5.ts, 4, 12)) +>blah : Symbol(blah, Decl(argumentsObjectIterator02_ES5.ts, 1, 7)) + + result.push(arg + arg); +>result.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) +>result : Symbol(result, Decl(argumentsObjectIterator02_ES5.ts, 3, 7)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES5.ts, 4, 12)) +>arg : Symbol(arg, Decl(argumentsObjectIterator02_ES5.ts, 4, 12)) + } + return <[any, any, any]>result; +>result : Symbol(result, Decl(argumentsObjectIterator02_ES5.ts, 3, 7)) +} + + diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES5.types b/tests/baselines/reference/argumentsObjectIterator02_ES5.types new file mode 100644 index 00000000000..0cfa15d9021 --- /dev/null +++ b/tests/baselines/reference/argumentsObjectIterator02_ES5.types @@ -0,0 +1,39 @@ +=== tests/cases/compiler/argumentsObjectIterator02_ES5.ts === +function doubleAndReturnAsArray(x: number, y: number, z: number): [number, number, number] { +>doubleAndReturnAsArray : (x: number, y: number, z: number) => [number, number, number] +>x : number +>y : number +>z : number + + let blah = arguments[Symbol.iterator]; +>blah : any +>arguments[Symbol.iterator] : any +>arguments : IArguments +>Symbol.iterator : any +>Symbol : any +>iterator : any + + let result = []; +>result : any[] +>[] : undefined[] + + for (let arg of blah()) { +>arg : any +>blah() : any +>blah : any + + result.push(arg + arg); +>result.push(arg + arg) : number +>result.push : (...items: any[]) => number +>result : any[] +>push : (...items: any[]) => number +>arg + arg : any +>arg : any +>arg : any + } + return <[any, any, any]>result; +><[any, any, any]>result : [any, any, any] +>result : any[] +} + + diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.symbols b/tests/baselines/reference/argumentsObjectIterator03_ES5.symbols new file mode 100644 index 00000000000..ff829062f5e --- /dev/null +++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.symbols @@ -0,0 +1,20 @@ +=== tests/cases/compiler/argumentsObjectIterator03_ES5.ts === +function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { +>asReversedTuple : Symbol(asReversedTuple, Decl(argumentsObjectIterator03_ES5.ts, 0, 0)) +>a : Symbol(a, Decl(argumentsObjectIterator03_ES5.ts, 0, 25)) +>b : Symbol(b, Decl(argumentsObjectIterator03_ES5.ts, 0, 35)) +>c : Symbol(c, Decl(argumentsObjectIterator03_ES5.ts, 0, 46)) + + let [x, y, z] = arguments; +>x : Symbol(x, Decl(argumentsObjectIterator03_ES5.ts, 1, 9)) +>y : Symbol(y, Decl(argumentsObjectIterator03_ES5.ts, 1, 11)) +>z : Symbol(z, Decl(argumentsObjectIterator03_ES5.ts, 1, 14)) +>arguments : Symbol(arguments) + + return [z, y, x]; +>z : Symbol(z, Decl(argumentsObjectIterator03_ES5.ts, 1, 14)) +>y : Symbol(y, Decl(argumentsObjectIterator03_ES5.ts, 1, 11)) +>x : Symbol(x, Decl(argumentsObjectIterator03_ES5.ts, 1, 9)) +} + + diff --git a/tests/baselines/reference/argumentsObjectIterator03_ES5.types b/tests/baselines/reference/argumentsObjectIterator03_ES5.types new file mode 100644 index 00000000000..cdedc6b01bd --- /dev/null +++ b/tests/baselines/reference/argumentsObjectIterator03_ES5.types @@ -0,0 +1,21 @@ +=== tests/cases/compiler/argumentsObjectIterator03_ES5.ts === +function asReversedTuple(a: number, b: string, c: boolean): [boolean, string, number] { +>asReversedTuple : (a: number, b: string, c: boolean) => [boolean, string, number] +>a : number +>b : string +>c : boolean + + let [x, y, z] = arguments; +>x : any +>y : any +>z : any +>arguments : IArguments + + return [z, y, x]; +>[z, y, x] : [any, any, any] +>z : any +>y : any +>x : any +} + + diff --git a/tests/baselines/reference/arithAssignTyping.symbols b/tests/baselines/reference/arithAssignTyping.symbols new file mode 100644 index 00000000000..2b65b6f8132 --- /dev/null +++ b/tests/baselines/reference/arithAssignTyping.symbols @@ -0,0 +1,40 @@ +=== tests/cases/compiler/arithAssignTyping.ts === +class f { } +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f += ''; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f += 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f -= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f *= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f /= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f %= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f &= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f |= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f <<= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f >>= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f >>>= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + +f ^= 1; // error +>f : Symbol(f, Decl(arithAssignTyping.ts, 0, 0)) + diff --git a/tests/baselines/reference/arithAssignTyping.types b/tests/baselines/reference/arithAssignTyping.types new file mode 100644 index 00000000000..ffecb1399de --- /dev/null +++ b/tests/baselines/reference/arithAssignTyping.types @@ -0,0 +1,64 @@ +=== tests/cases/compiler/arithAssignTyping.ts === +class f { } +>f : f + +f += ''; // error +>f += '' : string +>f : any +>'' : "" + +f += 1; // error +>f += 1 : any +>f : any +>1 : 1 + +f -= 1; // error +>f -= 1 : number +>f : any +>1 : 1 + +f *= 1; // error +>f *= 1 : number +>f : any +>1 : 1 + +f /= 1; // error +>f /= 1 : number +>f : any +>1 : 1 + +f %= 1; // error +>f %= 1 : number +>f : any +>1 : 1 + +f &= 1; // error +>f &= 1 : number +>f : any +>1 : 1 + +f |= 1; // error +>f |= 1 : number +>f : any +>1 : 1 + +f <<= 1; // error +>f <<= 1 : number +>f : any +>1 : 1 + +f >>= 1; // error +>f >>= 1 : number +>f : any +>1 : 1 + +f >>>= 1; // error +>f >>>= 1 : number +>f : any +>1 : 1 + +f ^= 1; // error +>f ^= 1 : number +>f : any +>1 : 1 + diff --git a/tests/baselines/reference/arithmeticOnInvalidTypes.symbols b/tests/baselines/reference/arithmeticOnInvalidTypes.symbols new file mode 100644 index 00000000000..d78af458a58 --- /dev/null +++ b/tests/baselines/reference/arithmeticOnInvalidTypes.symbols @@ -0,0 +1,29 @@ +=== tests/cases/compiler/arithmeticOnInvalidTypes.ts === +var x: Number; +>x : Symbol(x, Decl(arithmeticOnInvalidTypes.ts, 0, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var y: Number; +>y : Symbol(y, Decl(arithmeticOnInvalidTypes.ts, 1, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var z = x + y; +>z : Symbol(z, Decl(arithmeticOnInvalidTypes.ts, 2, 3)) +>x : Symbol(x, Decl(arithmeticOnInvalidTypes.ts, 0, 3)) +>y : Symbol(y, Decl(arithmeticOnInvalidTypes.ts, 1, 3)) + +var z2 = x - y; +>z2 : Symbol(z2, Decl(arithmeticOnInvalidTypes.ts, 3, 3)) +>x : Symbol(x, Decl(arithmeticOnInvalidTypes.ts, 0, 3)) +>y : Symbol(y, Decl(arithmeticOnInvalidTypes.ts, 1, 3)) + +var z3 = x * y; +>z3 : Symbol(z3, Decl(arithmeticOnInvalidTypes.ts, 4, 3)) +>x : Symbol(x, Decl(arithmeticOnInvalidTypes.ts, 0, 3)) +>y : Symbol(y, Decl(arithmeticOnInvalidTypes.ts, 1, 3)) + +var z4 = x / y; +>z4 : Symbol(z4, Decl(arithmeticOnInvalidTypes.ts, 5, 3)) +>x : Symbol(x, Decl(arithmeticOnInvalidTypes.ts, 0, 3)) +>y : Symbol(y, Decl(arithmeticOnInvalidTypes.ts, 1, 3)) + diff --git a/tests/baselines/reference/arithmeticOnInvalidTypes.types b/tests/baselines/reference/arithmeticOnInvalidTypes.types new file mode 100644 index 00000000000..330a9c67931 --- /dev/null +++ b/tests/baselines/reference/arithmeticOnInvalidTypes.types @@ -0,0 +1,33 @@ +=== tests/cases/compiler/arithmeticOnInvalidTypes.ts === +var x: Number; +>x : Number +>Number : Number + +var y: Number; +>y : Number +>Number : Number + +var z = x + y; +>z : any +>x + y : any +>x : Number +>y : Number + +var z2 = x - y; +>z2 : number +>x - y : number +>x : Number +>y : Number + +var z3 = x * y; +>z3 : number +>x * y : number +>x : Number +>y : Number + +var z4 = x / y; +>z4 : number +>x / y : number +>x : Number +>y : Number + diff --git a/tests/baselines/reference/arithmeticOnInvalidTypes2.symbols b/tests/baselines/reference/arithmeticOnInvalidTypes2.symbols new file mode 100644 index 00000000000..be6784d11f0 --- /dev/null +++ b/tests/baselines/reference/arithmeticOnInvalidTypes2.symbols @@ -0,0 +1,34 @@ +=== tests/cases/compiler/arithmeticOnInvalidTypes2.ts === +var obj = function f(a: T, b: T) { +>obj : Symbol(obj, Decl(arithmeticOnInvalidTypes2.ts, 0, 3)) +>f : Symbol(f, Decl(arithmeticOnInvalidTypes2.ts, 0, 9)) +>T : Symbol(T, Decl(arithmeticOnInvalidTypes2.ts, 0, 21)) +>a : Symbol(a, Decl(arithmeticOnInvalidTypes2.ts, 0, 24)) +>T : Symbol(T, Decl(arithmeticOnInvalidTypes2.ts, 0, 21)) +>b : Symbol(b, Decl(arithmeticOnInvalidTypes2.ts, 0, 29)) +>T : Symbol(T, Decl(arithmeticOnInvalidTypes2.ts, 0, 21)) + + var z1 = a + b; +>z1 : Symbol(z1, Decl(arithmeticOnInvalidTypes2.ts, 1, 7)) +>a : Symbol(a, Decl(arithmeticOnInvalidTypes2.ts, 0, 24)) +>b : Symbol(b, Decl(arithmeticOnInvalidTypes2.ts, 0, 29)) + + var z2 = a - b; +>z2 : Symbol(z2, Decl(arithmeticOnInvalidTypes2.ts, 2, 7)) +>a : Symbol(a, Decl(arithmeticOnInvalidTypes2.ts, 0, 24)) +>b : Symbol(b, Decl(arithmeticOnInvalidTypes2.ts, 0, 29)) + + var z3 = a * b; +>z3 : Symbol(z3, Decl(arithmeticOnInvalidTypes2.ts, 3, 7)) +>a : Symbol(a, Decl(arithmeticOnInvalidTypes2.ts, 0, 24)) +>b : Symbol(b, Decl(arithmeticOnInvalidTypes2.ts, 0, 29)) + + var z4 = a / b; +>z4 : Symbol(z4, Decl(arithmeticOnInvalidTypes2.ts, 4, 7)) +>a : Symbol(a, Decl(arithmeticOnInvalidTypes2.ts, 0, 24)) +>b : Symbol(b, Decl(arithmeticOnInvalidTypes2.ts, 0, 29)) + + return a; +>a : Symbol(a, Decl(arithmeticOnInvalidTypes2.ts, 0, 24)) + +}; diff --git a/tests/baselines/reference/arithmeticOnInvalidTypes2.types b/tests/baselines/reference/arithmeticOnInvalidTypes2.types new file mode 100644 index 00000000000..9608ad171cf --- /dev/null +++ b/tests/baselines/reference/arithmeticOnInvalidTypes2.types @@ -0,0 +1,39 @@ +=== tests/cases/compiler/arithmeticOnInvalidTypes2.ts === +var obj = function f(a: T, b: T) { +>obj : (a: T, b: T) => T +>function f(a: T, b: T) { var z1 = a + b; var z2 = a - b; var z3 = a * b; var z4 = a / b; return a;} : (a: T, b: T) => T +>f : (a: T, b: T) => T +>T : T +>a : T +>T : T +>b : T +>T : T + + var z1 = a + b; +>z1 : any +>a + b : any +>a : T +>b : T + + var z2 = a - b; +>z2 : number +>a - b : number +>a : T +>b : T + + var z3 = a * b; +>z3 : number +>a * b : number +>a : T +>b : T + + var z4 = a / b; +>z4 : number +>a / b : number +>a : T +>b : T + + return a; +>a : T + +}; diff --git a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols new file mode 100644 index 00000000000..3b2da85bdbe --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.symbols @@ -0,0 +1,2680 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithInvalidOperands.ts === +// these operators require their operands to be of type Any, the Number primitive type, or +// an enum type +enum E { a, b, c } +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>c : Symbol(E.c, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 14)) + +var a: any; +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var b: boolean; +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var c: number; +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var d: string; +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var e: { a: number }; +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 8)) + +var f: Number; +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +// All of the below should be an error unless otherwise noted +// operator * +var r1a1 = a * a; //ok +>r1a1 : Symbol(r1a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 13, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r1a2 = a * b; +>r1a2 : Symbol(r1a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 14, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r1a3 = a * c; //ok +>r1a3 : Symbol(r1a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 15, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r1a4 = a * d; +>r1a4 : Symbol(r1a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 16, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r1a5 = a * e; +>r1a5 : Symbol(r1a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 17, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r1a6 = a * f; +>r1a6 : Symbol(r1a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 18, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r1b1 = b * a; +>r1b1 : Symbol(r1b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 20, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r1b2 = b * b; +>r1b2 : Symbol(r1b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 21, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r1b3 = b * c; +>r1b3 : Symbol(r1b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 22, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r1b4 = b * d; +>r1b4 : Symbol(r1b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 23, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r1b5 = b * e; +>r1b5 : Symbol(r1b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 24, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r1b6 = b * f; +>r1b6 : Symbol(r1b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 25, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r1c1 = c * a; //ok +>r1c1 : Symbol(r1c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 27, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r1c2 = c * b; +>r1c2 : Symbol(r1c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 28, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r1c3 = c * c; //ok +>r1c3 : Symbol(r1c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 29, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r1c4 = c * d; +>r1c4 : Symbol(r1c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 30, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r1c5 = c * e; +>r1c5 : Symbol(r1c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 31, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r1c6 = c * f; +>r1c6 : Symbol(r1c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 32, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r1d1 = d * a; +>r1d1 : Symbol(r1d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 34, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r1d2 = d * b; +>r1d2 : Symbol(r1d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 35, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r1d3 = d * c; +>r1d3 : Symbol(r1d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 36, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r1d4 = d * d; +>r1d4 : Symbol(r1d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 37, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r1d5 = d * e; +>r1d5 : Symbol(r1d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 38, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r1d6 = d * f; +>r1d6 : Symbol(r1d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 39, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r1e1 = e * a; +>r1e1 : Symbol(r1e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 41, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r1e2 = e * b; +>r1e2 : Symbol(r1e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 42, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r1e3 = e * c; +>r1e3 : Symbol(r1e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 43, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r1e4 = e * d; +>r1e4 : Symbol(r1e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 44, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r1e5 = e * e; +>r1e5 : Symbol(r1e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 45, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r1e6 = e * f; +>r1e6 : Symbol(r1e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 46, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r1f1 = f * a; +>r1f1 : Symbol(r1f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 48, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r1f2 = f * b; +>r1f2 : Symbol(r1f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 49, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r1f3 = f * c; +>r1f3 : Symbol(r1f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 50, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r1f4 = f * d; +>r1f4 : Symbol(r1f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 51, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r1f5 = f * e; +>r1f5 : Symbol(r1f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 52, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r1f6 = f * f; +>r1f6 : Symbol(r1f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 53, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r1g1 = E.a * a; //ok +>r1g1 : Symbol(r1g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 55, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r1g2 = E.a * b; +>r1g2 : Symbol(r1g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 56, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r1g3 = E.a * c; //ok +>r1g3 : Symbol(r1g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 57, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r1g4 = E.a * d; +>r1g4 : Symbol(r1g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 58, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r1g5 = E.a * e; +>r1g5 : Symbol(r1g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 59, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r1g6 = E.a * f; +>r1g6 : Symbol(r1g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 60, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r1h1 = a * E.b; //ok +>r1h1 : Symbol(r1h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 62, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r1h2 = b * E.b; +>r1h2 : Symbol(r1h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 63, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r1h3 = c * E.b; //ok +>r1h3 : Symbol(r1h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 64, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r1h4 = d * E.b; +>r1h4 : Symbol(r1h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 65, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r1h5 = e * E.b; +>r1h5 : Symbol(r1h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 66, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r1h6 = f * E.b; +>r1h6 : Symbol(r1h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 67, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator / +var r2a1 = a / a; //ok +>r2a1 : Symbol(r2a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 70, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r2a2 = a / b; +>r2a2 : Symbol(r2a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 71, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r2a3 = a / c; //ok +>r2a3 : Symbol(r2a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 72, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r2a4 = a / d; +>r2a4 : Symbol(r2a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 73, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r2a5 = a / e; +>r2a5 : Symbol(r2a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 74, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r2a6 = a / f; +>r2a6 : Symbol(r2a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 75, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r2b1 = b / a; +>r2b1 : Symbol(r2b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 77, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r2b2 = b / b; +>r2b2 : Symbol(r2b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 78, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r2b3 = b / c; +>r2b3 : Symbol(r2b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 79, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r2b4 = b / d; +>r2b4 : Symbol(r2b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 80, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r2b5 = b / e; +>r2b5 : Symbol(r2b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 81, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r2b6 = b / f; +>r2b6 : Symbol(r2b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 82, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r2c1 = c / a; //ok +>r2c1 : Symbol(r2c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 84, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r2c2 = c / b; +>r2c2 : Symbol(r2c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 85, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r2c3 = c / c; //ok +>r2c3 : Symbol(r2c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 86, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r2c4 = c / d; +>r2c4 : Symbol(r2c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 87, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r2c5 = c / e; +>r2c5 : Symbol(r2c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 88, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r2c6 = c / f; +>r2c6 : Symbol(r2c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 89, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r2d1 = d / a; +>r2d1 : Symbol(r2d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 91, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r2d2 = d / b; +>r2d2 : Symbol(r2d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 92, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r2d3 = d / c; +>r2d3 : Symbol(r2d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 93, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r2d4 = d / d; +>r2d4 : Symbol(r2d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 94, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r2d5 = d / e; +>r2d5 : Symbol(r2d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 95, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r2d6 = d / f; +>r2d6 : Symbol(r2d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 96, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r2e1 = e / a; +>r2e1 : Symbol(r2e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 98, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r2e2 = e / b; +>r2e2 : Symbol(r2e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 99, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r2e3 = e / c; +>r2e3 : Symbol(r2e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 100, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r2e4 = e / d; +>r2e4 : Symbol(r2e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 101, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r2e5 = e / e; +>r2e5 : Symbol(r2e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 102, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r2e6 = e / f; +>r2e6 : Symbol(r2e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 103, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r2f1 = f / a; +>r2f1 : Symbol(r2f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 105, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r2f2 = f / b; +>r2f2 : Symbol(r2f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 106, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r2f3 = f / c; +>r2f3 : Symbol(r2f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 107, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r2f4 = f / d; +>r2f4 : Symbol(r2f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 108, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r2f5 = f / e; +>r2f5 : Symbol(r2f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 109, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r2f6 = f / f; +>r2f6 : Symbol(r2f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 110, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r2g1 = E.a / a; //ok +>r2g1 : Symbol(r2g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 112, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r2g2 = E.a / b; +>r2g2 : Symbol(r2g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 113, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r2g3 = E.a / c; //ok +>r2g3 : Symbol(r2g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 114, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r2g4 = E.a / d; +>r2g4 : Symbol(r2g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 115, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r2g5 = E.a / e; +>r2g5 : Symbol(r2g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 116, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r2g6 = E.a / f; +>r2g6 : Symbol(r2g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 117, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r2h1 = a / E.b; //ok +>r2h1 : Symbol(r2h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 119, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r2h2 = b / E.b; +>r2h2 : Symbol(r2h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 120, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r2h3 = c / E.b; //ok +>r2h3 : Symbol(r2h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 121, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r2h4 = d / E.b; +>r2h4 : Symbol(r2h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 122, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r2h5 = e / E.b; +>r2h5 : Symbol(r2h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 123, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r2h6 = f / E.b; +>r2h6 : Symbol(r2h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 124, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator % +var r3a1 = a % a; //ok +>r3a1 : Symbol(r3a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 127, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r3a2 = a % b; +>r3a2 : Symbol(r3a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 128, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r3a3 = a % c; //ok +>r3a3 : Symbol(r3a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 129, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r3a4 = a % d; +>r3a4 : Symbol(r3a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 130, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r3a5 = a % e; +>r3a5 : Symbol(r3a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 131, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r3a6 = a % f; +>r3a6 : Symbol(r3a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 132, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r3b1 = b % a; +>r3b1 : Symbol(r3b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 134, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r3b2 = b % b; +>r3b2 : Symbol(r3b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 135, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r3b3 = b % c; +>r3b3 : Symbol(r3b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 136, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r3b4 = b % d; +>r3b4 : Symbol(r3b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 137, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r3b5 = b % e; +>r3b5 : Symbol(r3b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 138, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r3b6 = b % f; +>r3b6 : Symbol(r3b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 139, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r3c1 = c % a; //ok +>r3c1 : Symbol(r3c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 141, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r3c2 = c % b; +>r3c2 : Symbol(r3c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 142, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r3c3 = c % c; //ok +>r3c3 : Symbol(r3c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 143, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r3c4 = c % d; +>r3c4 : Symbol(r3c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 144, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r3c5 = c % e; +>r3c5 : Symbol(r3c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 145, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r3c6 = c % f; +>r3c6 : Symbol(r3c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 146, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r3d1 = d % a; +>r3d1 : Symbol(r3d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 148, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r3d2 = d % b; +>r3d2 : Symbol(r3d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 149, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r3d3 = d % c; +>r3d3 : Symbol(r3d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 150, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r3d4 = d % d; +>r3d4 : Symbol(r3d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 151, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r3d5 = d % e; +>r3d5 : Symbol(r3d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 152, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r3d6 = d % f; +>r3d6 : Symbol(r3d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 153, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r3e1 = e % a; +>r3e1 : Symbol(r3e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 155, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r3e2 = e % b; +>r3e2 : Symbol(r3e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 156, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r3e3 = e % c; +>r3e3 : Symbol(r3e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 157, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r3e4 = e % d; +>r3e4 : Symbol(r3e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 158, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r3e5 = e % e; +>r3e5 : Symbol(r3e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 159, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r3e6 = e % f; +>r3e6 : Symbol(r3e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 160, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r3f1 = f % a; +>r3f1 : Symbol(r3f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 162, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r3f2 = f % b; +>r3f2 : Symbol(r3f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 163, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r3f3 = f % c; +>r3f3 : Symbol(r3f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 164, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r3f4 = f % d; +>r3f4 : Symbol(r3f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 165, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r3f5 = f % e; +>r3f5 : Symbol(r3f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 166, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r3f6 = f % f; +>r3f6 : Symbol(r3f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 167, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r3g1 = E.a % a; //ok +>r3g1 : Symbol(r3g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 169, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r3g2 = E.a % b; +>r3g2 : Symbol(r3g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 170, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r3g3 = E.a % c; //ok +>r3g3 : Symbol(r3g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 171, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r3g4 = E.a % d; +>r3g4 : Symbol(r3g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 172, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r3g5 = E.a % e; +>r3g5 : Symbol(r3g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 173, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r3g6 = E.a % f; +>r3g6 : Symbol(r3g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 174, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r3h1 = a % E.b; //ok +>r3h1 : Symbol(r3h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 176, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r3h2 = b % E.b; +>r3h2 : Symbol(r3h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 177, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r3h3 = c % E.b; //ok +>r3h3 : Symbol(r3h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 178, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r3h4 = d % E.b; +>r3h4 : Symbol(r3h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 179, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r3h5 = e % E.b; +>r3h5 : Symbol(r3h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 180, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r3h6 = f % E.b; +>r3h6 : Symbol(r3h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 181, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator - +var r4a1 = a - a; //ok +>r4a1 : Symbol(r4a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 184, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r4a2 = a - b; +>r4a2 : Symbol(r4a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 185, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r4a3 = a - c; //ok +>r4a3 : Symbol(r4a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 186, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r4a4 = a - d; +>r4a4 : Symbol(r4a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 187, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r4a5 = a - e; +>r4a5 : Symbol(r4a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 188, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r4a6 = a - f; +>r4a6 : Symbol(r4a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 189, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r4b1 = b - a; +>r4b1 : Symbol(r4b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 191, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r4b2 = b - b; +>r4b2 : Symbol(r4b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 192, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r4b3 = b - c; +>r4b3 : Symbol(r4b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 193, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r4b4 = b - d; +>r4b4 : Symbol(r4b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 194, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r4b5 = b - e; +>r4b5 : Symbol(r4b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 195, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r4b6 = b - f; +>r4b6 : Symbol(r4b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 196, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r4c1 = c - a; //ok +>r4c1 : Symbol(r4c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 198, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r4c2 = c - b; +>r4c2 : Symbol(r4c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 199, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r4c3 = c - c; //ok +>r4c3 : Symbol(r4c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 200, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r4c4 = c - d; +>r4c4 : Symbol(r4c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 201, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r4c5 = c - e; +>r4c5 : Symbol(r4c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 202, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r4c6 = c - f; +>r4c6 : Symbol(r4c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 203, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r4d1 = d - a; +>r4d1 : Symbol(r4d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 205, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r4d2 = d - b; +>r4d2 : Symbol(r4d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 206, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r4d3 = d - c; +>r4d3 : Symbol(r4d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 207, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r4d4 = d - d; +>r4d4 : Symbol(r4d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 208, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r4d5 = d - e; +>r4d5 : Symbol(r4d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 209, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r4d6 = d - f; +>r4d6 : Symbol(r4d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 210, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r4e1 = e - a; +>r4e1 : Symbol(r4e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 212, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r4e2 = e - b; +>r4e2 : Symbol(r4e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 213, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r4e3 = e - c; +>r4e3 : Symbol(r4e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 214, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r4e4 = e - d; +>r4e4 : Symbol(r4e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 215, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r4e5 = e - e; +>r4e5 : Symbol(r4e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 216, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r4e6 = e - f; +>r4e6 : Symbol(r4e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 217, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r4f1 = f - a; +>r4f1 : Symbol(r4f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 219, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r4f2 = f - b; +>r4f2 : Symbol(r4f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 220, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r4f3 = f - c; +>r4f3 : Symbol(r4f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 221, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r4f4 = f - d; +>r4f4 : Symbol(r4f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 222, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r4f5 = f - e; +>r4f5 : Symbol(r4f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 223, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r4f6 = f - f; +>r4f6 : Symbol(r4f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 224, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r4g1 = E.a - a; //ok +>r4g1 : Symbol(r4g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 226, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r4g2 = E.a - b; +>r4g2 : Symbol(r4g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 227, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r4g3 = E.a - c; //ok +>r4g3 : Symbol(r4g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 228, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r4g4 = E.a - d; +>r4g4 : Symbol(r4g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 229, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r4g5 = E.a - e; +>r4g5 : Symbol(r4g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 230, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r4g6 = E.a - f; +>r4g6 : Symbol(r4g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 231, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r4h1 = a - E.b; //ok +>r4h1 : Symbol(r4h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 233, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r4h2 = b - E.b; +>r4h2 : Symbol(r4h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 234, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r4h3 = c - E.b; //ok +>r4h3 : Symbol(r4h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 235, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r4h4 = d - E.b; +>r4h4 : Symbol(r4h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 236, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r4h5 = e - E.b; +>r4h5 : Symbol(r4h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 237, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r4h6 = f - E.b; +>r4h6 : Symbol(r4h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 238, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator << +var r5a1 = a << a; //ok +>r5a1 : Symbol(r5a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 241, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r5a2 = a << b; +>r5a2 : Symbol(r5a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 242, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r5a3 = a << c; //ok +>r5a3 : Symbol(r5a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 243, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r5a4 = a << d; +>r5a4 : Symbol(r5a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 244, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r5a5 = a << e; +>r5a5 : Symbol(r5a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 245, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r5a6 = a << f; +>r5a6 : Symbol(r5a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 246, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r5b1 = b << a; +>r5b1 : Symbol(r5b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 248, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r5b2 = b << b; +>r5b2 : Symbol(r5b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 249, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r5b3 = b << c; +>r5b3 : Symbol(r5b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 250, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r5b4 = b << d; +>r5b4 : Symbol(r5b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 251, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r5b5 = b << e; +>r5b5 : Symbol(r5b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 252, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r5b6 = b << f; +>r5b6 : Symbol(r5b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 253, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r5c1 = c << a; //ok +>r5c1 : Symbol(r5c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 255, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r5c2 = c << b; +>r5c2 : Symbol(r5c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 256, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r5c3 = c << c; //ok +>r5c3 : Symbol(r5c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 257, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r5c4 = c << d; +>r5c4 : Symbol(r5c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 258, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r5c5 = c << e; +>r5c5 : Symbol(r5c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 259, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r5c6 = c << f; +>r5c6 : Symbol(r5c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 260, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r5d1 = d << a; +>r5d1 : Symbol(r5d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 262, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r5d2 = d << b; +>r5d2 : Symbol(r5d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 263, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r5d3 = d << c; +>r5d3 : Symbol(r5d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 264, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r5d4 = d << d; +>r5d4 : Symbol(r5d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 265, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r5d5 = d << e; +>r5d5 : Symbol(r5d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 266, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r5d6 = d << f; +>r5d6 : Symbol(r5d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 267, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r5e1 = e << a; +>r5e1 : Symbol(r5e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 269, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r5e2 = e << b; +>r5e2 : Symbol(r5e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 270, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r5e3 = e << c; +>r5e3 : Symbol(r5e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 271, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r5e4 = e << d; +>r5e4 : Symbol(r5e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 272, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r5e5 = e << e; +>r5e5 : Symbol(r5e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 273, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r5e6 = e << f; +>r5e6 : Symbol(r5e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 274, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r5f1 = f << a; +>r5f1 : Symbol(r5f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 276, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r5f2 = f << b; +>r5f2 : Symbol(r5f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 277, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r5f3 = f << c; +>r5f3 : Symbol(r5f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 278, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r5f4 = f << d; +>r5f4 : Symbol(r5f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 279, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r5f5 = f << e; +>r5f5 : Symbol(r5f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 280, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r5f6 = f << f; +>r5f6 : Symbol(r5f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 281, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r5g1 = E.a << a; //ok +>r5g1 : Symbol(r5g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 283, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r5g2 = E.a << b; +>r5g2 : Symbol(r5g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 284, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r5g3 = E.a << c; //ok +>r5g3 : Symbol(r5g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 285, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r5g4 = E.a << d; +>r5g4 : Symbol(r5g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 286, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r5g5 = E.a << e; +>r5g5 : Symbol(r5g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 287, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r5g6 = E.a << f; +>r5g6 : Symbol(r5g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 288, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r5h1 = a << E.b; //ok +>r5h1 : Symbol(r5h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 290, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r5h2 = b << E.b; +>r5h2 : Symbol(r5h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 291, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r5h3 = c << E.b; //ok +>r5h3 : Symbol(r5h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 292, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r5h4 = d << E.b; +>r5h4 : Symbol(r5h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 293, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r5h5 = e << E.b; +>r5h5 : Symbol(r5h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 294, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r5h6 = f << E.b; +>r5h6 : Symbol(r5h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 295, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator >> +var r6a1 = a >> a; //ok +>r6a1 : Symbol(r6a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 298, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r6a2 = a >> b; +>r6a2 : Symbol(r6a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 299, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r6a3 = a >> c; //ok +>r6a3 : Symbol(r6a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 300, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r6a4 = a >> d; +>r6a4 : Symbol(r6a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 301, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r6a5 = a >> e; +>r6a5 : Symbol(r6a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 302, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r6a6 = a >> f; +>r6a6 : Symbol(r6a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 303, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r6b1 = b >> a; +>r6b1 : Symbol(r6b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 305, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r6b2 = b >> b; +>r6b2 : Symbol(r6b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 306, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r6b3 = b >> c; +>r6b3 : Symbol(r6b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 307, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r6b4 = b >> d; +>r6b4 : Symbol(r6b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 308, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r6b5 = b >> e; +>r6b5 : Symbol(r6b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 309, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r6b6 = b >> f; +>r6b6 : Symbol(r6b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 310, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r6c1 = c >> a; //ok +>r6c1 : Symbol(r6c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 312, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r6c2 = c >> b; +>r6c2 : Symbol(r6c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 313, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r6c3 = c >> c; //ok +>r6c3 : Symbol(r6c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 314, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r6c4 = c >> d; +>r6c4 : Symbol(r6c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 315, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r6c5 = c >> e; +>r6c5 : Symbol(r6c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 316, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r6c6 = c >> f; +>r6c6 : Symbol(r6c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 317, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r6d1 = d >> a; +>r6d1 : Symbol(r6d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 319, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r6d2 = d >> b; +>r6d2 : Symbol(r6d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 320, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r6d3 = d >> c; +>r6d3 : Symbol(r6d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 321, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r6d4 = d >> d; +>r6d4 : Symbol(r6d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 322, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r6d5 = d >> e; +>r6d5 : Symbol(r6d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 323, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r6d6 = d >> f; +>r6d6 : Symbol(r6d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 324, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r6e1 = e >> a; +>r6e1 : Symbol(r6e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 326, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r6e2 = e >> b; +>r6e2 : Symbol(r6e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 327, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r6e3 = e >> c; +>r6e3 : Symbol(r6e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 328, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r6e4 = e >> d; +>r6e4 : Symbol(r6e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 329, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r6e5 = e >> e; +>r6e5 : Symbol(r6e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 330, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r6e6 = e >> f; +>r6e6 : Symbol(r6e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 331, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r6f1 = f >> a; +>r6f1 : Symbol(r6f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 333, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r6f2 = f >> b; +>r6f2 : Symbol(r6f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 334, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r6f3 = f >> c; +>r6f3 : Symbol(r6f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 335, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r6f4 = f >> d; +>r6f4 : Symbol(r6f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 336, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r6f5 = f >> e; +>r6f5 : Symbol(r6f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 337, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r6f6 = f >> f; +>r6f6 : Symbol(r6f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 338, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r6g1 = E.a >> a; //ok +>r6g1 : Symbol(r6g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 340, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r6g2 = E.a >> b; +>r6g2 : Symbol(r6g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 341, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r6g3 = E.a >> c; //ok +>r6g3 : Symbol(r6g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 342, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r6g4 = E.a >> d; +>r6g4 : Symbol(r6g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 343, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r6g5 = E.a >> e; +>r6g5 : Symbol(r6g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 344, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r6g6 = E.a >> f; +>r6g6 : Symbol(r6g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 345, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r6h1 = a >> E.b; //ok +>r6h1 : Symbol(r6h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 347, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r6h2 = b >> E.b; +>r6h2 : Symbol(r6h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 348, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r6h3 = c >> E.b; //ok +>r6h3 : Symbol(r6h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 349, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r6h4 = d >> E.b; +>r6h4 : Symbol(r6h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 350, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r6h5 = e >> E.b; +>r6h5 : Symbol(r6h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 351, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r6h6 = f >> E.b; +>r6h6 : Symbol(r6h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 352, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator >>> +var r7a1 = a >>> a; //ok +>r7a1 : Symbol(r7a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 355, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r7a2 = a >>> b; +>r7a2 : Symbol(r7a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 356, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r7a3 = a >>> c; //ok +>r7a3 : Symbol(r7a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 357, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r7a4 = a >>> d; +>r7a4 : Symbol(r7a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 358, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r7a5 = a >>> e; +>r7a5 : Symbol(r7a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 359, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r7a6 = a >>> f; +>r7a6 : Symbol(r7a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 360, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r7b1 = b >>> a; +>r7b1 : Symbol(r7b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 362, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r7b2 = b >>> b; +>r7b2 : Symbol(r7b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 363, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r7b3 = b >>> c; +>r7b3 : Symbol(r7b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 364, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r7b4 = b >>> d; +>r7b4 : Symbol(r7b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 365, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r7b5 = b >>> e; +>r7b5 : Symbol(r7b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 366, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r7b6 = b >>> f; +>r7b6 : Symbol(r7b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 367, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r7c1 = c >>> a; //ok +>r7c1 : Symbol(r7c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 369, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r7c2 = c >>> b; +>r7c2 : Symbol(r7c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 370, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r7c3 = c >>> c; //ok +>r7c3 : Symbol(r7c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 371, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r7c4 = c >>> d; +>r7c4 : Symbol(r7c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 372, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r7c5 = c >>> e; +>r7c5 : Symbol(r7c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 373, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r7c6 = c >>> f; +>r7c6 : Symbol(r7c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 374, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r7d1 = d >>> a; +>r7d1 : Symbol(r7d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 376, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r7d2 = d >>> b; +>r7d2 : Symbol(r7d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 377, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r7d3 = d >>> c; +>r7d3 : Symbol(r7d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 378, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r7d4 = d >>> d; +>r7d4 : Symbol(r7d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 379, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r7d5 = d >>> e; +>r7d5 : Symbol(r7d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 380, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r7d6 = d >>> f; +>r7d6 : Symbol(r7d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 381, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r7e1 = e >>> a; +>r7e1 : Symbol(r7e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 383, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r7e2 = e >>> b; +>r7e2 : Symbol(r7e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 384, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r7e3 = e >>> c; +>r7e3 : Symbol(r7e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 385, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r7e4 = e >>> d; +>r7e4 : Symbol(r7e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 386, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r7e5 = e >>> e; +>r7e5 : Symbol(r7e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 387, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r7e6 = e >>> f; +>r7e6 : Symbol(r7e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 388, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r7f1 = f >>> a; +>r7f1 : Symbol(r7f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 390, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r7f2 = f >>> b; +>r7f2 : Symbol(r7f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 391, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r7f3 = f >>> c; +>r7f3 : Symbol(r7f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 392, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r7f4 = f >>> d; +>r7f4 : Symbol(r7f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 393, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r7f5 = f >>> e; +>r7f5 : Symbol(r7f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 394, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r7f6 = f >>> f; +>r7f6 : Symbol(r7f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 395, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r7g1 = E.a >>> a; //ok +>r7g1 : Symbol(r7g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 397, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r7g2 = E.a >>> b; +>r7g2 : Symbol(r7g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 398, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r7g3 = E.a >>> c; //ok +>r7g3 : Symbol(r7g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 399, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r7g4 = E.a >>> d; +>r7g4 : Symbol(r7g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 400, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r7g5 = E.a >>> e; +>r7g5 : Symbol(r7g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 401, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r7g6 = E.a >>> f; +>r7g6 : Symbol(r7g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 402, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r7h1 = a >>> E.b; //ok +>r7h1 : Symbol(r7h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 404, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r7h2 = b >>> E.b; +>r7h2 : Symbol(r7h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 405, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r7h3 = c >>> E.b; //ok +>r7h3 : Symbol(r7h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 406, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r7h4 = d >>> E.b; +>r7h4 : Symbol(r7h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 407, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r7h5 = e >>> E.b; +>r7h5 : Symbol(r7h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 408, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r7h6 = f >>> E.b; +>r7h6 : Symbol(r7h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 409, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator & +var r8a1 = a & a; //ok +>r8a1 : Symbol(r8a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 412, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r8a2 = a & b; +>r8a2 : Symbol(r8a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 413, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r8a3 = a & c; //ok +>r8a3 : Symbol(r8a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 414, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r8a4 = a & d; +>r8a4 : Symbol(r8a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 415, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r8a5 = a & e; +>r8a5 : Symbol(r8a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 416, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r8a6 = a & f; +>r8a6 : Symbol(r8a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 417, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r8b1 = b & a; +>r8b1 : Symbol(r8b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 419, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r8b2 = b & b; +>r8b2 : Symbol(r8b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 420, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r8b3 = b & c; +>r8b3 : Symbol(r8b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 421, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r8b4 = b & d; +>r8b4 : Symbol(r8b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 422, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r8b5 = b & e; +>r8b5 : Symbol(r8b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 423, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r8b6 = b & f; +>r8b6 : Symbol(r8b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 424, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r8c1 = c & a; //ok +>r8c1 : Symbol(r8c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 426, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r8c2 = c & b; +>r8c2 : Symbol(r8c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 427, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r8c3 = c & c; //ok +>r8c3 : Symbol(r8c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 428, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r8c4 = c & d; +>r8c4 : Symbol(r8c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 429, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r8c5 = c & e; +>r8c5 : Symbol(r8c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 430, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r8c6 = c & f; +>r8c6 : Symbol(r8c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 431, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r8d1 = d & a; +>r8d1 : Symbol(r8d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 433, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r8d2 = d & b; +>r8d2 : Symbol(r8d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 434, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r8d3 = d & c; +>r8d3 : Symbol(r8d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 435, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r8d4 = d & d; +>r8d4 : Symbol(r8d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 436, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r8d5 = d & e; +>r8d5 : Symbol(r8d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 437, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r8d6 = d & f; +>r8d6 : Symbol(r8d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 438, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r8e1 = e & a; +>r8e1 : Symbol(r8e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 440, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r8e2 = e & b; +>r8e2 : Symbol(r8e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 441, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r8e3 = e & c; +>r8e3 : Symbol(r8e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 442, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r8e4 = e & d; +>r8e4 : Symbol(r8e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 443, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r8e5 = e & e; +>r8e5 : Symbol(r8e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 444, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r8e6 = e & f; +>r8e6 : Symbol(r8e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 445, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r8f1 = f & a; +>r8f1 : Symbol(r8f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 447, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r8f2 = f & b; +>r8f2 : Symbol(r8f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 448, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r8f3 = f & c; +>r8f3 : Symbol(r8f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 449, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r8f4 = f & d; +>r8f4 : Symbol(r8f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 450, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r8f5 = f & e; +>r8f5 : Symbol(r8f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 451, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r8f6 = f & f; +>r8f6 : Symbol(r8f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 452, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r8g1 = E.a & a; //ok +>r8g1 : Symbol(r8g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 454, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r8g2 = E.a & b; +>r8g2 : Symbol(r8g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 455, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r8g3 = E.a & c; //ok +>r8g3 : Symbol(r8g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 456, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r8g4 = E.a & d; +>r8g4 : Symbol(r8g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 457, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r8g5 = E.a & e; +>r8g5 : Symbol(r8g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 458, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r8g6 = E.a & f; +>r8g6 : Symbol(r8g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 459, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r8h1 = a & E.b; //ok +>r8h1 : Symbol(r8h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 461, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r8h2 = b & E.b; +>r8h2 : Symbol(r8h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 462, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r8h3 = c & E.b; //ok +>r8h3 : Symbol(r8h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 463, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r8h4 = d & E.b; +>r8h4 : Symbol(r8h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 464, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r8h5 = e & E.b; +>r8h5 : Symbol(r8h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 465, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r8h6 = f & E.b; +>r8h6 : Symbol(r8h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 466, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator ^ +var r9a1 = a ^ a; //ok +>r9a1 : Symbol(r9a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 469, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r9a2 = a ^ b; +>r9a2 : Symbol(r9a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 470, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r9a3 = a ^ c; //ok +>r9a3 : Symbol(r9a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 471, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r9a4 = a ^ d; +>r9a4 : Symbol(r9a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 472, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r9a5 = a ^ e; +>r9a5 : Symbol(r9a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 473, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r9a6 = a ^ f; +>r9a6 : Symbol(r9a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 474, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r9b1 = b ^ a; +>r9b1 : Symbol(r9b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 476, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r9b2 = b ^ b; +>r9b2 : Symbol(r9b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 477, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r9b3 = b ^ c; +>r9b3 : Symbol(r9b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 478, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r9b4 = b ^ d; +>r9b4 : Symbol(r9b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 479, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r9b5 = b ^ e; +>r9b5 : Symbol(r9b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 480, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r9b6 = b ^ f; +>r9b6 : Symbol(r9b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 481, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r9c1 = c ^ a; //ok +>r9c1 : Symbol(r9c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 483, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r9c2 = c ^ b; +>r9c2 : Symbol(r9c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 484, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r9c3 = c ^ c; //ok +>r9c3 : Symbol(r9c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 485, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r9c4 = c ^ d; +>r9c4 : Symbol(r9c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 486, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r9c5 = c ^ e; +>r9c5 : Symbol(r9c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 487, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r9c6 = c ^ f; +>r9c6 : Symbol(r9c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 488, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r9d1 = d ^ a; +>r9d1 : Symbol(r9d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 490, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r9d2 = d ^ b; +>r9d2 : Symbol(r9d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 491, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r9d3 = d ^ c; +>r9d3 : Symbol(r9d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 492, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r9d4 = d ^ d; +>r9d4 : Symbol(r9d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 493, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r9d5 = d ^ e; +>r9d5 : Symbol(r9d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 494, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r9d6 = d ^ f; +>r9d6 : Symbol(r9d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 495, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r9e1 = e ^ a; +>r9e1 : Symbol(r9e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 497, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r9e2 = e ^ b; +>r9e2 : Symbol(r9e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 498, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r9e3 = e ^ c; +>r9e3 : Symbol(r9e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 499, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r9e4 = e ^ d; +>r9e4 : Symbol(r9e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 500, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r9e5 = e ^ e; +>r9e5 : Symbol(r9e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 501, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r9e6 = e ^ f; +>r9e6 : Symbol(r9e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 502, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r9f1 = f ^ a; +>r9f1 : Symbol(r9f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 504, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r9f2 = f ^ b; +>r9f2 : Symbol(r9f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 505, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r9f3 = f ^ c; +>r9f3 : Symbol(r9f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 506, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r9f4 = f ^ d; +>r9f4 : Symbol(r9f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 507, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r9f5 = f ^ e; +>r9f5 : Symbol(r9f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 508, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r9f6 = f ^ f; +>r9f6 : Symbol(r9f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 509, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r9g1 = E.a ^ a; //ok +>r9g1 : Symbol(r9g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 511, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r9g2 = E.a ^ b; +>r9g2 : Symbol(r9g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 512, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r9g3 = E.a ^ c; //ok +>r9g3 : Symbol(r9g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 513, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r9g4 = E.a ^ d; +>r9g4 : Symbol(r9g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 514, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r9g5 = E.a ^ e; +>r9g5 : Symbol(r9g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 515, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r9g6 = E.a ^ f; +>r9g6 : Symbol(r9g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 516, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r9h1 = a ^ E.b; //ok +>r9h1 : Symbol(r9h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 518, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r9h2 = b ^ E.b; +>r9h2 : Symbol(r9h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 519, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r9h3 = c ^ E.b; //ok +>r9h3 : Symbol(r9h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 520, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r9h4 = d ^ E.b; +>r9h4 : Symbol(r9h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 521, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r9h5 = e ^ E.b; +>r9h5 : Symbol(r9h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 522, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r9h6 = f ^ E.b; +>r9h6 : Symbol(r9h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 523, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +// operator | +var r10a1 = a | a; //ok +>r10a1 : Symbol(r10a1, Decl(arithmeticOperatorWithInvalidOperands.ts, 526, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r10a2 = a | b; +>r10a2 : Symbol(r10a2, Decl(arithmeticOperatorWithInvalidOperands.ts, 527, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r10a3 = a | c; //ok +>r10a3 : Symbol(r10a3, Decl(arithmeticOperatorWithInvalidOperands.ts, 528, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r10a4 = a | d; +>r10a4 : Symbol(r10a4, Decl(arithmeticOperatorWithInvalidOperands.ts, 529, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r10a5 = a | e; +>r10a5 : Symbol(r10a5, Decl(arithmeticOperatorWithInvalidOperands.ts, 530, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r10a6 = a | f; +>r10a6 : Symbol(r10a6, Decl(arithmeticOperatorWithInvalidOperands.ts, 531, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r10b1 = b | a; +>r10b1 : Symbol(r10b1, Decl(arithmeticOperatorWithInvalidOperands.ts, 533, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r10b2 = b | b; +>r10b2 : Symbol(r10b2, Decl(arithmeticOperatorWithInvalidOperands.ts, 534, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r10b3 = b | c; +>r10b3 : Symbol(r10b3, Decl(arithmeticOperatorWithInvalidOperands.ts, 535, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r10b4 = b | d; +>r10b4 : Symbol(r10b4, Decl(arithmeticOperatorWithInvalidOperands.ts, 536, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r10b5 = b | e; +>r10b5 : Symbol(r10b5, Decl(arithmeticOperatorWithInvalidOperands.ts, 537, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r10b6 = b | f; +>r10b6 : Symbol(r10b6, Decl(arithmeticOperatorWithInvalidOperands.ts, 538, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r10c1 = c | a; //ok +>r10c1 : Symbol(r10c1, Decl(arithmeticOperatorWithInvalidOperands.ts, 540, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r10c2 = c | b; +>r10c2 : Symbol(r10c2, Decl(arithmeticOperatorWithInvalidOperands.ts, 541, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r10c3 = c | c; //ok +>r10c3 : Symbol(r10c3, Decl(arithmeticOperatorWithInvalidOperands.ts, 542, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r10c4 = c | d; +>r10c4 : Symbol(r10c4, Decl(arithmeticOperatorWithInvalidOperands.ts, 543, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r10c5 = c | e; +>r10c5 : Symbol(r10c5, Decl(arithmeticOperatorWithInvalidOperands.ts, 544, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r10c6 = c | f; +>r10c6 : Symbol(r10c6, Decl(arithmeticOperatorWithInvalidOperands.ts, 545, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r10d1 = d | a; +>r10d1 : Symbol(r10d1, Decl(arithmeticOperatorWithInvalidOperands.ts, 547, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r10d2 = d | b; +>r10d2 : Symbol(r10d2, Decl(arithmeticOperatorWithInvalidOperands.ts, 548, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r10d3 = d | c; +>r10d3 : Symbol(r10d3, Decl(arithmeticOperatorWithInvalidOperands.ts, 549, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r10d4 = d | d; +>r10d4 : Symbol(r10d4, Decl(arithmeticOperatorWithInvalidOperands.ts, 550, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r10d5 = d | e; +>r10d5 : Symbol(r10d5, Decl(arithmeticOperatorWithInvalidOperands.ts, 551, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r10d6 = d | f; +>r10d6 : Symbol(r10d6, Decl(arithmeticOperatorWithInvalidOperands.ts, 552, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r10e1 = e | a; +>r10e1 : Symbol(r10e1, Decl(arithmeticOperatorWithInvalidOperands.ts, 554, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r10e2 = e | b; +>r10e2 : Symbol(r10e2, Decl(arithmeticOperatorWithInvalidOperands.ts, 555, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r10e3 = e | c; +>r10e3 : Symbol(r10e3, Decl(arithmeticOperatorWithInvalidOperands.ts, 556, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r10e4 = e | d; +>r10e4 : Symbol(r10e4, Decl(arithmeticOperatorWithInvalidOperands.ts, 557, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r10e5 = e | e; +>r10e5 : Symbol(r10e5, Decl(arithmeticOperatorWithInvalidOperands.ts, 558, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r10e6 = e | f; +>r10e6 : Symbol(r10e6, Decl(arithmeticOperatorWithInvalidOperands.ts, 559, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r10f1 = f | a; +>r10f1 : Symbol(r10f1, Decl(arithmeticOperatorWithInvalidOperands.ts, 561, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r10f2 = f | b; +>r10f2 : Symbol(r10f2, Decl(arithmeticOperatorWithInvalidOperands.ts, 562, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r10f3 = f | c; +>r10f3 : Symbol(r10f3, Decl(arithmeticOperatorWithInvalidOperands.ts, 563, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r10f4 = f | d; +>r10f4 : Symbol(r10f4, Decl(arithmeticOperatorWithInvalidOperands.ts, 564, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r10f5 = f | e; +>r10f5 : Symbol(r10f5, Decl(arithmeticOperatorWithInvalidOperands.ts, 565, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r10f6 = f | f; +>r10f6 : Symbol(r10f6, Decl(arithmeticOperatorWithInvalidOperands.ts, 566, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r10g1 = E.a | a; //ok +>r10g1 : Symbol(r10g1, Decl(arithmeticOperatorWithInvalidOperands.ts, 568, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) + +var r10g2 = E.a | b; +>r10g2 : Symbol(r10g2, Decl(arithmeticOperatorWithInvalidOperands.ts, 569, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) + +var r10g3 = E.a | c; //ok +>r10g3 : Symbol(r10g3, Decl(arithmeticOperatorWithInvalidOperands.ts, 570, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) + +var r10g4 = E.a | d; +>r10g4 : Symbol(r10g4, Decl(arithmeticOperatorWithInvalidOperands.ts, 571, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) + +var r10g5 = E.a | e; +>r10g5 : Symbol(r10g5, Decl(arithmeticOperatorWithInvalidOperands.ts, 572, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) + +var r10g6 = E.a | f; +>r10g6 : Symbol(r10g6, Decl(arithmeticOperatorWithInvalidOperands.ts, 573, 3)) +>E.a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>a : Symbol(E.a, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 8)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) + +var r10h1 = a | E.b; //ok +>r10h1 : Symbol(r10h1, Decl(arithmeticOperatorWithInvalidOperands.ts, 575, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithInvalidOperands.ts, 4, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r10h2 = b | E.b; +>r10h2 : Symbol(r10h2, Decl(arithmeticOperatorWithInvalidOperands.ts, 576, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithInvalidOperands.ts, 5, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r10h3 = c | E.b; //ok +>r10h3 : Symbol(r10h3, Decl(arithmeticOperatorWithInvalidOperands.ts, 577, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithInvalidOperands.ts, 6, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r10h4 = d | E.b; +>r10h4 : Symbol(r10h4, Decl(arithmeticOperatorWithInvalidOperands.ts, 578, 3)) +>d : Symbol(d, Decl(arithmeticOperatorWithInvalidOperands.ts, 7, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r10h5 = e | E.b; +>r10h5 : Symbol(r10h5, Decl(arithmeticOperatorWithInvalidOperands.ts, 579, 3)) +>e : Symbol(e, Decl(arithmeticOperatorWithInvalidOperands.ts, 8, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + +var r10h6 = f | E.b; +>r10h6 : Symbol(r10h6, Decl(arithmeticOperatorWithInvalidOperands.ts, 580, 3)) +>f : Symbol(f, Decl(arithmeticOperatorWithInvalidOperands.ts, 9, 3)) +>E.b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) +>E : Symbol(E, Decl(arithmeticOperatorWithInvalidOperands.ts, 0, 0)) +>b : Symbol(E.b, Decl(arithmeticOperatorWithInvalidOperands.ts, 2, 11)) + diff --git a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types new file mode 100644 index 00000000000..7bd878e19ff --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.types @@ -0,0 +1,3160 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithInvalidOperands.ts === +// these operators require their operands to be of type Any, the Number primitive type, or +// an enum type +enum E { a, b, c } +>E : E +>a : E.a +>b : E.b +>c : E.c + +var a: any; +>a : any + +var b: boolean; +>b : boolean + +var c: number; +>c : number + +var d: string; +>d : string + +var e: { a: number }; +>e : { a: number; } +>a : number + +var f: Number; +>f : Number +>Number : Number + +// All of the below should be an error unless otherwise noted +// operator * +var r1a1 = a * a; //ok +>r1a1 : number +>a * a : number +>a : any +>a : any + +var r1a2 = a * b; +>r1a2 : number +>a * b : number +>a : any +>b : boolean + +var r1a3 = a * c; //ok +>r1a3 : number +>a * c : number +>a : any +>c : number + +var r1a4 = a * d; +>r1a4 : number +>a * d : number +>a : any +>d : string + +var r1a5 = a * e; +>r1a5 : number +>a * e : number +>a : any +>e : { a: number; } + +var r1a6 = a * f; +>r1a6 : number +>a * f : number +>a : any +>f : Number + +var r1b1 = b * a; +>r1b1 : number +>b * a : number +>b : boolean +>a : any + +var r1b2 = b * b; +>r1b2 : number +>b * b : number +>b : boolean +>b : boolean + +var r1b3 = b * c; +>r1b3 : number +>b * c : number +>b : boolean +>c : number + +var r1b4 = b * d; +>r1b4 : number +>b * d : number +>b : boolean +>d : string + +var r1b5 = b * e; +>r1b5 : number +>b * e : number +>b : boolean +>e : { a: number; } + +var r1b6 = b * f; +>r1b6 : number +>b * f : number +>b : boolean +>f : Number + +var r1c1 = c * a; //ok +>r1c1 : number +>c * a : number +>c : number +>a : any + +var r1c2 = c * b; +>r1c2 : number +>c * b : number +>c : number +>b : boolean + +var r1c3 = c * c; //ok +>r1c3 : number +>c * c : number +>c : number +>c : number + +var r1c4 = c * d; +>r1c4 : number +>c * d : number +>c : number +>d : string + +var r1c5 = c * e; +>r1c5 : number +>c * e : number +>c : number +>e : { a: number; } + +var r1c6 = c * f; +>r1c6 : number +>c * f : number +>c : number +>f : Number + +var r1d1 = d * a; +>r1d1 : number +>d * a : number +>d : string +>a : any + +var r1d2 = d * b; +>r1d2 : number +>d * b : number +>d : string +>b : boolean + +var r1d3 = d * c; +>r1d3 : number +>d * c : number +>d : string +>c : number + +var r1d4 = d * d; +>r1d4 : number +>d * d : number +>d : string +>d : string + +var r1d5 = d * e; +>r1d5 : number +>d * e : number +>d : string +>e : { a: number; } + +var r1d6 = d * f; +>r1d6 : number +>d * f : number +>d : string +>f : Number + +var r1e1 = e * a; +>r1e1 : number +>e * a : number +>e : { a: number; } +>a : any + +var r1e2 = e * b; +>r1e2 : number +>e * b : number +>e : { a: number; } +>b : boolean + +var r1e3 = e * c; +>r1e3 : number +>e * c : number +>e : { a: number; } +>c : number + +var r1e4 = e * d; +>r1e4 : number +>e * d : number +>e : { a: number; } +>d : string + +var r1e5 = e * e; +>r1e5 : number +>e * e : number +>e : { a: number; } +>e : { a: number; } + +var r1e6 = e * f; +>r1e6 : number +>e * f : number +>e : { a: number; } +>f : Number + +var r1f1 = f * a; +>r1f1 : number +>f * a : number +>f : Number +>a : any + +var r1f2 = f * b; +>r1f2 : number +>f * b : number +>f : Number +>b : boolean + +var r1f3 = f * c; +>r1f3 : number +>f * c : number +>f : Number +>c : number + +var r1f4 = f * d; +>r1f4 : number +>f * d : number +>f : Number +>d : string + +var r1f5 = f * e; +>r1f5 : number +>f * e : number +>f : Number +>e : { a: number; } + +var r1f6 = f * f; +>r1f6 : number +>f * f : number +>f : Number +>f : Number + +var r1g1 = E.a * a; //ok +>r1g1 : number +>E.a * a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r1g2 = E.a * b; +>r1g2 : number +>E.a * b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r1g3 = E.a * c; //ok +>r1g3 : number +>E.a * c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r1g4 = E.a * d; +>r1g4 : number +>E.a * d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r1g5 = E.a * e; +>r1g5 : number +>E.a * e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r1g6 = E.a * f; +>r1g6 : number +>E.a * f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r1h1 = a * E.b; //ok +>r1h1 : number +>a * E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r1h2 = b * E.b; +>r1h2 : number +>b * E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r1h3 = c * E.b; //ok +>r1h3 : number +>c * E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r1h4 = d * E.b; +>r1h4 : number +>d * E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r1h5 = e * E.b; +>r1h5 : number +>e * E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r1h6 = f * E.b; +>r1h6 : number +>f * E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator / +var r2a1 = a / a; //ok +>r2a1 : number +>a / a : number +>a : any +>a : any + +var r2a2 = a / b; +>r2a2 : number +>a / b : number +>a : any +>b : boolean + +var r2a3 = a / c; //ok +>r2a3 : number +>a / c : number +>a : any +>c : number + +var r2a4 = a / d; +>r2a4 : number +>a / d : number +>a : any +>d : string + +var r2a5 = a / e; +>r2a5 : number +>a / e : number +>a : any +>e : { a: number; } + +var r2a6 = a / f; +>r2a6 : number +>a / f : number +>a : any +>f : Number + +var r2b1 = b / a; +>r2b1 : number +>b / a : number +>b : boolean +>a : any + +var r2b2 = b / b; +>r2b2 : number +>b / b : number +>b : boolean +>b : boolean + +var r2b3 = b / c; +>r2b3 : number +>b / c : number +>b : boolean +>c : number + +var r2b4 = b / d; +>r2b4 : number +>b / d : number +>b : boolean +>d : string + +var r2b5 = b / e; +>r2b5 : number +>b / e : number +>b : boolean +>e : { a: number; } + +var r2b6 = b / f; +>r2b6 : number +>b / f : number +>b : boolean +>f : Number + +var r2c1 = c / a; //ok +>r2c1 : number +>c / a : number +>c : number +>a : any + +var r2c2 = c / b; +>r2c2 : number +>c / b : number +>c : number +>b : boolean + +var r2c3 = c / c; //ok +>r2c3 : number +>c / c : number +>c : number +>c : number + +var r2c4 = c / d; +>r2c4 : number +>c / d : number +>c : number +>d : string + +var r2c5 = c / e; +>r2c5 : number +>c / e : number +>c : number +>e : { a: number; } + +var r2c6 = c / f; +>r2c6 : number +>c / f : number +>c : number +>f : Number + +var r2d1 = d / a; +>r2d1 : number +>d / a : number +>d : string +>a : any + +var r2d2 = d / b; +>r2d2 : number +>d / b : number +>d : string +>b : boolean + +var r2d3 = d / c; +>r2d3 : number +>d / c : number +>d : string +>c : number + +var r2d4 = d / d; +>r2d4 : number +>d / d : number +>d : string +>d : string + +var r2d5 = d / e; +>r2d5 : number +>d / e : number +>d : string +>e : { a: number; } + +var r2d6 = d / f; +>r2d6 : number +>d / f : number +>d : string +>f : Number + +var r2e1 = e / a; +>r2e1 : number +>e / a : number +>e : { a: number; } +>a : any + +var r2e2 = e / b; +>r2e2 : number +>e / b : number +>e : { a: number; } +>b : boolean + +var r2e3 = e / c; +>r2e3 : number +>e / c : number +>e : { a: number; } +>c : number + +var r2e4 = e / d; +>r2e4 : number +>e / d : number +>e : { a: number; } +>d : string + +var r2e5 = e / e; +>r2e5 : number +>e / e : number +>e : { a: number; } +>e : { a: number; } + +var r2e6 = e / f; +>r2e6 : number +>e / f : number +>e : { a: number; } +>f : Number + +var r2f1 = f / a; +>r2f1 : number +>f / a : number +>f : Number +>a : any + +var r2f2 = f / b; +>r2f2 : number +>f / b : number +>f : Number +>b : boolean + +var r2f3 = f / c; +>r2f3 : number +>f / c : number +>f : Number +>c : number + +var r2f4 = f / d; +>r2f4 : number +>f / d : number +>f : Number +>d : string + +var r2f5 = f / e; +>r2f5 : number +>f / e : number +>f : Number +>e : { a: number; } + +var r2f6 = f / f; +>r2f6 : number +>f / f : number +>f : Number +>f : Number + +var r2g1 = E.a / a; //ok +>r2g1 : number +>E.a / a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r2g2 = E.a / b; +>r2g2 : number +>E.a / b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r2g3 = E.a / c; //ok +>r2g3 : number +>E.a / c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r2g4 = E.a / d; +>r2g4 : number +>E.a / d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r2g5 = E.a / e; +>r2g5 : number +>E.a / e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r2g6 = E.a / f; +>r2g6 : number +>E.a / f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r2h1 = a / E.b; //ok +>r2h1 : number +>a / E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r2h2 = b / E.b; +>r2h2 : number +>b / E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r2h3 = c / E.b; //ok +>r2h3 : number +>c / E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r2h4 = d / E.b; +>r2h4 : number +>d / E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r2h5 = e / E.b; +>r2h5 : number +>e / E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r2h6 = f / E.b; +>r2h6 : number +>f / E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator % +var r3a1 = a % a; //ok +>r3a1 : number +>a % a : number +>a : any +>a : any + +var r3a2 = a % b; +>r3a2 : number +>a % b : number +>a : any +>b : boolean + +var r3a3 = a % c; //ok +>r3a3 : number +>a % c : number +>a : any +>c : number + +var r3a4 = a % d; +>r3a4 : number +>a % d : number +>a : any +>d : string + +var r3a5 = a % e; +>r3a5 : number +>a % e : number +>a : any +>e : { a: number; } + +var r3a6 = a % f; +>r3a6 : number +>a % f : number +>a : any +>f : Number + +var r3b1 = b % a; +>r3b1 : number +>b % a : number +>b : boolean +>a : any + +var r3b2 = b % b; +>r3b2 : number +>b % b : number +>b : boolean +>b : boolean + +var r3b3 = b % c; +>r3b3 : number +>b % c : number +>b : boolean +>c : number + +var r3b4 = b % d; +>r3b4 : number +>b % d : number +>b : boolean +>d : string + +var r3b5 = b % e; +>r3b5 : number +>b % e : number +>b : boolean +>e : { a: number; } + +var r3b6 = b % f; +>r3b6 : number +>b % f : number +>b : boolean +>f : Number + +var r3c1 = c % a; //ok +>r3c1 : number +>c % a : number +>c : number +>a : any + +var r3c2 = c % b; +>r3c2 : number +>c % b : number +>c : number +>b : boolean + +var r3c3 = c % c; //ok +>r3c3 : number +>c % c : number +>c : number +>c : number + +var r3c4 = c % d; +>r3c4 : number +>c % d : number +>c : number +>d : string + +var r3c5 = c % e; +>r3c5 : number +>c % e : number +>c : number +>e : { a: number; } + +var r3c6 = c % f; +>r3c6 : number +>c % f : number +>c : number +>f : Number + +var r3d1 = d % a; +>r3d1 : number +>d % a : number +>d : string +>a : any + +var r3d2 = d % b; +>r3d2 : number +>d % b : number +>d : string +>b : boolean + +var r3d3 = d % c; +>r3d3 : number +>d % c : number +>d : string +>c : number + +var r3d4 = d % d; +>r3d4 : number +>d % d : number +>d : string +>d : string + +var r3d5 = d % e; +>r3d5 : number +>d % e : number +>d : string +>e : { a: number; } + +var r3d6 = d % f; +>r3d6 : number +>d % f : number +>d : string +>f : Number + +var r3e1 = e % a; +>r3e1 : number +>e % a : number +>e : { a: number; } +>a : any + +var r3e2 = e % b; +>r3e2 : number +>e % b : number +>e : { a: number; } +>b : boolean + +var r3e3 = e % c; +>r3e3 : number +>e % c : number +>e : { a: number; } +>c : number + +var r3e4 = e % d; +>r3e4 : number +>e % d : number +>e : { a: number; } +>d : string + +var r3e5 = e % e; +>r3e5 : number +>e % e : number +>e : { a: number; } +>e : { a: number; } + +var r3e6 = e % f; +>r3e6 : number +>e % f : number +>e : { a: number; } +>f : Number + +var r3f1 = f % a; +>r3f1 : number +>f % a : number +>f : Number +>a : any + +var r3f2 = f % b; +>r3f2 : number +>f % b : number +>f : Number +>b : boolean + +var r3f3 = f % c; +>r3f3 : number +>f % c : number +>f : Number +>c : number + +var r3f4 = f % d; +>r3f4 : number +>f % d : number +>f : Number +>d : string + +var r3f5 = f % e; +>r3f5 : number +>f % e : number +>f : Number +>e : { a: number; } + +var r3f6 = f % f; +>r3f6 : number +>f % f : number +>f : Number +>f : Number + +var r3g1 = E.a % a; //ok +>r3g1 : number +>E.a % a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r3g2 = E.a % b; +>r3g2 : number +>E.a % b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r3g3 = E.a % c; //ok +>r3g3 : number +>E.a % c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r3g4 = E.a % d; +>r3g4 : number +>E.a % d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r3g5 = E.a % e; +>r3g5 : number +>E.a % e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r3g6 = E.a % f; +>r3g6 : number +>E.a % f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r3h1 = a % E.b; //ok +>r3h1 : number +>a % E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r3h2 = b % E.b; +>r3h2 : number +>b % E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r3h3 = c % E.b; //ok +>r3h3 : number +>c % E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r3h4 = d % E.b; +>r3h4 : number +>d % E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r3h5 = e % E.b; +>r3h5 : number +>e % E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r3h6 = f % E.b; +>r3h6 : number +>f % E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator - +var r4a1 = a - a; //ok +>r4a1 : number +>a - a : number +>a : any +>a : any + +var r4a2 = a - b; +>r4a2 : number +>a - b : number +>a : any +>b : boolean + +var r4a3 = a - c; //ok +>r4a3 : number +>a - c : number +>a : any +>c : number + +var r4a4 = a - d; +>r4a4 : number +>a - d : number +>a : any +>d : string + +var r4a5 = a - e; +>r4a5 : number +>a - e : number +>a : any +>e : { a: number; } + +var r4a6 = a - f; +>r4a6 : number +>a - f : number +>a : any +>f : Number + +var r4b1 = b - a; +>r4b1 : number +>b - a : number +>b : boolean +>a : any + +var r4b2 = b - b; +>r4b2 : number +>b - b : number +>b : boolean +>b : boolean + +var r4b3 = b - c; +>r4b3 : number +>b - c : number +>b : boolean +>c : number + +var r4b4 = b - d; +>r4b4 : number +>b - d : number +>b : boolean +>d : string + +var r4b5 = b - e; +>r4b5 : number +>b - e : number +>b : boolean +>e : { a: number; } + +var r4b6 = b - f; +>r4b6 : number +>b - f : number +>b : boolean +>f : Number + +var r4c1 = c - a; //ok +>r4c1 : number +>c - a : number +>c : number +>a : any + +var r4c2 = c - b; +>r4c2 : number +>c - b : number +>c : number +>b : boolean + +var r4c3 = c - c; //ok +>r4c3 : number +>c - c : number +>c : number +>c : number + +var r4c4 = c - d; +>r4c4 : number +>c - d : number +>c : number +>d : string + +var r4c5 = c - e; +>r4c5 : number +>c - e : number +>c : number +>e : { a: number; } + +var r4c6 = c - f; +>r4c6 : number +>c - f : number +>c : number +>f : Number + +var r4d1 = d - a; +>r4d1 : number +>d - a : number +>d : string +>a : any + +var r4d2 = d - b; +>r4d2 : number +>d - b : number +>d : string +>b : boolean + +var r4d3 = d - c; +>r4d3 : number +>d - c : number +>d : string +>c : number + +var r4d4 = d - d; +>r4d4 : number +>d - d : number +>d : string +>d : string + +var r4d5 = d - e; +>r4d5 : number +>d - e : number +>d : string +>e : { a: number; } + +var r4d6 = d - f; +>r4d6 : number +>d - f : number +>d : string +>f : Number + +var r4e1 = e - a; +>r4e1 : number +>e - a : number +>e : { a: number; } +>a : any + +var r4e2 = e - b; +>r4e2 : number +>e - b : number +>e : { a: number; } +>b : boolean + +var r4e3 = e - c; +>r4e3 : number +>e - c : number +>e : { a: number; } +>c : number + +var r4e4 = e - d; +>r4e4 : number +>e - d : number +>e : { a: number; } +>d : string + +var r4e5 = e - e; +>r4e5 : number +>e - e : number +>e : { a: number; } +>e : { a: number; } + +var r4e6 = e - f; +>r4e6 : number +>e - f : number +>e : { a: number; } +>f : Number + +var r4f1 = f - a; +>r4f1 : number +>f - a : number +>f : Number +>a : any + +var r4f2 = f - b; +>r4f2 : number +>f - b : number +>f : Number +>b : boolean + +var r4f3 = f - c; +>r4f3 : number +>f - c : number +>f : Number +>c : number + +var r4f4 = f - d; +>r4f4 : number +>f - d : number +>f : Number +>d : string + +var r4f5 = f - e; +>r4f5 : number +>f - e : number +>f : Number +>e : { a: number; } + +var r4f6 = f - f; +>r4f6 : number +>f - f : number +>f : Number +>f : Number + +var r4g1 = E.a - a; //ok +>r4g1 : number +>E.a - a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r4g2 = E.a - b; +>r4g2 : number +>E.a - b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r4g3 = E.a - c; //ok +>r4g3 : number +>E.a - c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r4g4 = E.a - d; +>r4g4 : number +>E.a - d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r4g5 = E.a - e; +>r4g5 : number +>E.a - e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r4g6 = E.a - f; +>r4g6 : number +>E.a - f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r4h1 = a - E.b; //ok +>r4h1 : number +>a - E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r4h2 = b - E.b; +>r4h2 : number +>b - E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r4h3 = c - E.b; //ok +>r4h3 : number +>c - E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r4h4 = d - E.b; +>r4h4 : number +>d - E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r4h5 = e - E.b; +>r4h5 : number +>e - E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r4h6 = f - E.b; +>r4h6 : number +>f - E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator << +var r5a1 = a << a; //ok +>r5a1 : number +>a << a : number +>a : any +>a : any + +var r5a2 = a << b; +>r5a2 : number +>a << b : number +>a : any +>b : boolean + +var r5a3 = a << c; //ok +>r5a3 : number +>a << c : number +>a : any +>c : number + +var r5a4 = a << d; +>r5a4 : number +>a << d : number +>a : any +>d : string + +var r5a5 = a << e; +>r5a5 : number +>a << e : number +>a : any +>e : { a: number; } + +var r5a6 = a << f; +>r5a6 : number +>a << f : number +>a : any +>f : Number + +var r5b1 = b << a; +>r5b1 : number +>b << a : number +>b : boolean +>a : any + +var r5b2 = b << b; +>r5b2 : number +>b << b : number +>b : boolean +>b : boolean + +var r5b3 = b << c; +>r5b3 : number +>b << c : number +>b : boolean +>c : number + +var r5b4 = b << d; +>r5b4 : number +>b << d : number +>b : boolean +>d : string + +var r5b5 = b << e; +>r5b5 : number +>b << e : number +>b : boolean +>e : { a: number; } + +var r5b6 = b << f; +>r5b6 : number +>b << f : number +>b : boolean +>f : Number + +var r5c1 = c << a; //ok +>r5c1 : number +>c << a : number +>c : number +>a : any + +var r5c2 = c << b; +>r5c2 : number +>c << b : number +>c : number +>b : boolean + +var r5c3 = c << c; //ok +>r5c3 : number +>c << c : number +>c : number +>c : number + +var r5c4 = c << d; +>r5c4 : number +>c << d : number +>c : number +>d : string + +var r5c5 = c << e; +>r5c5 : number +>c << e : number +>c : number +>e : { a: number; } + +var r5c6 = c << f; +>r5c6 : number +>c << f : number +>c : number +>f : Number + +var r5d1 = d << a; +>r5d1 : number +>d << a : number +>d : string +>a : any + +var r5d2 = d << b; +>r5d2 : number +>d << b : number +>d : string +>b : boolean + +var r5d3 = d << c; +>r5d3 : number +>d << c : number +>d : string +>c : number + +var r5d4 = d << d; +>r5d4 : number +>d << d : number +>d : string +>d : string + +var r5d5 = d << e; +>r5d5 : number +>d << e : number +>d : string +>e : { a: number; } + +var r5d6 = d << f; +>r5d6 : number +>d << f : number +>d : string +>f : Number + +var r5e1 = e << a; +>r5e1 : number +>e << a : number +>e : { a: number; } +>a : any + +var r5e2 = e << b; +>r5e2 : number +>e << b : number +>e : { a: number; } +>b : boolean + +var r5e3 = e << c; +>r5e3 : number +>e << c : number +>e : { a: number; } +>c : number + +var r5e4 = e << d; +>r5e4 : number +>e << d : number +>e : { a: number; } +>d : string + +var r5e5 = e << e; +>r5e5 : number +>e << e : number +>e : { a: number; } +>e : { a: number; } + +var r5e6 = e << f; +>r5e6 : number +>e << f : number +>e : { a: number; } +>f : Number + +var r5f1 = f << a; +>r5f1 : number +>f << a : number +>f : Number +>a : any + +var r5f2 = f << b; +>r5f2 : number +>f << b : number +>f : Number +>b : boolean + +var r5f3 = f << c; +>r5f3 : number +>f << c : number +>f : Number +>c : number + +var r5f4 = f << d; +>r5f4 : number +>f << d : number +>f : Number +>d : string + +var r5f5 = f << e; +>r5f5 : number +>f << e : number +>f : Number +>e : { a: number; } + +var r5f6 = f << f; +>r5f6 : number +>f << f : number +>f : Number +>f : Number + +var r5g1 = E.a << a; //ok +>r5g1 : number +>E.a << a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r5g2 = E.a << b; +>r5g2 : number +>E.a << b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r5g3 = E.a << c; //ok +>r5g3 : number +>E.a << c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r5g4 = E.a << d; +>r5g4 : number +>E.a << d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r5g5 = E.a << e; +>r5g5 : number +>E.a << e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r5g6 = E.a << f; +>r5g6 : number +>E.a << f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r5h1 = a << E.b; //ok +>r5h1 : number +>a << E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r5h2 = b << E.b; +>r5h2 : number +>b << E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r5h3 = c << E.b; //ok +>r5h3 : number +>c << E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r5h4 = d << E.b; +>r5h4 : number +>d << E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r5h5 = e << E.b; +>r5h5 : number +>e << E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r5h6 = f << E.b; +>r5h6 : number +>f << E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator >> +var r6a1 = a >> a; //ok +>r6a1 : number +>a >> a : number +>a : any +>a : any + +var r6a2 = a >> b; +>r6a2 : number +>a >> b : number +>a : any +>b : boolean + +var r6a3 = a >> c; //ok +>r6a3 : number +>a >> c : number +>a : any +>c : number + +var r6a4 = a >> d; +>r6a4 : number +>a >> d : number +>a : any +>d : string + +var r6a5 = a >> e; +>r6a5 : number +>a >> e : number +>a : any +>e : { a: number; } + +var r6a6 = a >> f; +>r6a6 : number +>a >> f : number +>a : any +>f : Number + +var r6b1 = b >> a; +>r6b1 : number +>b >> a : number +>b : boolean +>a : any + +var r6b2 = b >> b; +>r6b2 : number +>b >> b : number +>b : boolean +>b : boolean + +var r6b3 = b >> c; +>r6b3 : number +>b >> c : number +>b : boolean +>c : number + +var r6b4 = b >> d; +>r6b4 : number +>b >> d : number +>b : boolean +>d : string + +var r6b5 = b >> e; +>r6b5 : number +>b >> e : number +>b : boolean +>e : { a: number; } + +var r6b6 = b >> f; +>r6b6 : number +>b >> f : number +>b : boolean +>f : Number + +var r6c1 = c >> a; //ok +>r6c1 : number +>c >> a : number +>c : number +>a : any + +var r6c2 = c >> b; +>r6c2 : number +>c >> b : number +>c : number +>b : boolean + +var r6c3 = c >> c; //ok +>r6c3 : number +>c >> c : number +>c : number +>c : number + +var r6c4 = c >> d; +>r6c4 : number +>c >> d : number +>c : number +>d : string + +var r6c5 = c >> e; +>r6c5 : number +>c >> e : number +>c : number +>e : { a: number; } + +var r6c6 = c >> f; +>r6c6 : number +>c >> f : number +>c : number +>f : Number + +var r6d1 = d >> a; +>r6d1 : number +>d >> a : number +>d : string +>a : any + +var r6d2 = d >> b; +>r6d2 : number +>d >> b : number +>d : string +>b : boolean + +var r6d3 = d >> c; +>r6d3 : number +>d >> c : number +>d : string +>c : number + +var r6d4 = d >> d; +>r6d4 : number +>d >> d : number +>d : string +>d : string + +var r6d5 = d >> e; +>r6d5 : number +>d >> e : number +>d : string +>e : { a: number; } + +var r6d6 = d >> f; +>r6d6 : number +>d >> f : number +>d : string +>f : Number + +var r6e1 = e >> a; +>r6e1 : number +>e >> a : number +>e : { a: number; } +>a : any + +var r6e2 = e >> b; +>r6e2 : number +>e >> b : number +>e : { a: number; } +>b : boolean + +var r6e3 = e >> c; +>r6e3 : number +>e >> c : number +>e : { a: number; } +>c : number + +var r6e4 = e >> d; +>r6e4 : number +>e >> d : number +>e : { a: number; } +>d : string + +var r6e5 = e >> e; +>r6e5 : number +>e >> e : number +>e : { a: number; } +>e : { a: number; } + +var r6e6 = e >> f; +>r6e6 : number +>e >> f : number +>e : { a: number; } +>f : Number + +var r6f1 = f >> a; +>r6f1 : number +>f >> a : number +>f : Number +>a : any + +var r6f2 = f >> b; +>r6f2 : number +>f >> b : number +>f : Number +>b : boolean + +var r6f3 = f >> c; +>r6f3 : number +>f >> c : number +>f : Number +>c : number + +var r6f4 = f >> d; +>r6f4 : number +>f >> d : number +>f : Number +>d : string + +var r6f5 = f >> e; +>r6f5 : number +>f >> e : number +>f : Number +>e : { a: number; } + +var r6f6 = f >> f; +>r6f6 : number +>f >> f : number +>f : Number +>f : Number + +var r6g1 = E.a >> a; //ok +>r6g1 : number +>E.a >> a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r6g2 = E.a >> b; +>r6g2 : number +>E.a >> b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r6g3 = E.a >> c; //ok +>r6g3 : number +>E.a >> c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r6g4 = E.a >> d; +>r6g4 : number +>E.a >> d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r6g5 = E.a >> e; +>r6g5 : number +>E.a >> e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r6g6 = E.a >> f; +>r6g6 : number +>E.a >> f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r6h1 = a >> E.b; //ok +>r6h1 : number +>a >> E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r6h2 = b >> E.b; +>r6h2 : number +>b >> E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r6h3 = c >> E.b; //ok +>r6h3 : number +>c >> E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r6h4 = d >> E.b; +>r6h4 : number +>d >> E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r6h5 = e >> E.b; +>r6h5 : number +>e >> E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r6h6 = f >> E.b; +>r6h6 : number +>f >> E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator >>> +var r7a1 = a >>> a; //ok +>r7a1 : number +>a >>> a : number +>a : any +>a : any + +var r7a2 = a >>> b; +>r7a2 : number +>a >>> b : number +>a : any +>b : boolean + +var r7a3 = a >>> c; //ok +>r7a3 : number +>a >>> c : number +>a : any +>c : number + +var r7a4 = a >>> d; +>r7a4 : number +>a >>> d : number +>a : any +>d : string + +var r7a5 = a >>> e; +>r7a5 : number +>a >>> e : number +>a : any +>e : { a: number; } + +var r7a6 = a >>> f; +>r7a6 : number +>a >>> f : number +>a : any +>f : Number + +var r7b1 = b >>> a; +>r7b1 : number +>b >>> a : number +>b : boolean +>a : any + +var r7b2 = b >>> b; +>r7b2 : number +>b >>> b : number +>b : boolean +>b : boolean + +var r7b3 = b >>> c; +>r7b3 : number +>b >>> c : number +>b : boolean +>c : number + +var r7b4 = b >>> d; +>r7b4 : number +>b >>> d : number +>b : boolean +>d : string + +var r7b5 = b >>> e; +>r7b5 : number +>b >>> e : number +>b : boolean +>e : { a: number; } + +var r7b6 = b >>> f; +>r7b6 : number +>b >>> f : number +>b : boolean +>f : Number + +var r7c1 = c >>> a; //ok +>r7c1 : number +>c >>> a : number +>c : number +>a : any + +var r7c2 = c >>> b; +>r7c2 : number +>c >>> b : number +>c : number +>b : boolean + +var r7c3 = c >>> c; //ok +>r7c3 : number +>c >>> c : number +>c : number +>c : number + +var r7c4 = c >>> d; +>r7c4 : number +>c >>> d : number +>c : number +>d : string + +var r7c5 = c >>> e; +>r7c5 : number +>c >>> e : number +>c : number +>e : { a: number; } + +var r7c6 = c >>> f; +>r7c6 : number +>c >>> f : number +>c : number +>f : Number + +var r7d1 = d >>> a; +>r7d1 : number +>d >>> a : number +>d : string +>a : any + +var r7d2 = d >>> b; +>r7d2 : number +>d >>> b : number +>d : string +>b : boolean + +var r7d3 = d >>> c; +>r7d3 : number +>d >>> c : number +>d : string +>c : number + +var r7d4 = d >>> d; +>r7d4 : number +>d >>> d : number +>d : string +>d : string + +var r7d5 = d >>> e; +>r7d5 : number +>d >>> e : number +>d : string +>e : { a: number; } + +var r7d6 = d >>> f; +>r7d6 : number +>d >>> f : number +>d : string +>f : Number + +var r7e1 = e >>> a; +>r7e1 : number +>e >>> a : number +>e : { a: number; } +>a : any + +var r7e2 = e >>> b; +>r7e2 : number +>e >>> b : number +>e : { a: number; } +>b : boolean + +var r7e3 = e >>> c; +>r7e3 : number +>e >>> c : number +>e : { a: number; } +>c : number + +var r7e4 = e >>> d; +>r7e4 : number +>e >>> d : number +>e : { a: number; } +>d : string + +var r7e5 = e >>> e; +>r7e5 : number +>e >>> e : number +>e : { a: number; } +>e : { a: number; } + +var r7e6 = e >>> f; +>r7e6 : number +>e >>> f : number +>e : { a: number; } +>f : Number + +var r7f1 = f >>> a; +>r7f1 : number +>f >>> a : number +>f : Number +>a : any + +var r7f2 = f >>> b; +>r7f2 : number +>f >>> b : number +>f : Number +>b : boolean + +var r7f3 = f >>> c; +>r7f3 : number +>f >>> c : number +>f : Number +>c : number + +var r7f4 = f >>> d; +>r7f4 : number +>f >>> d : number +>f : Number +>d : string + +var r7f5 = f >>> e; +>r7f5 : number +>f >>> e : number +>f : Number +>e : { a: number; } + +var r7f6 = f >>> f; +>r7f6 : number +>f >>> f : number +>f : Number +>f : Number + +var r7g1 = E.a >>> a; //ok +>r7g1 : number +>E.a >>> a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r7g2 = E.a >>> b; +>r7g2 : number +>E.a >>> b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r7g3 = E.a >>> c; //ok +>r7g3 : number +>E.a >>> c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r7g4 = E.a >>> d; +>r7g4 : number +>E.a >>> d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r7g5 = E.a >>> e; +>r7g5 : number +>E.a >>> e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r7g6 = E.a >>> f; +>r7g6 : number +>E.a >>> f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r7h1 = a >>> E.b; //ok +>r7h1 : number +>a >>> E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r7h2 = b >>> E.b; +>r7h2 : number +>b >>> E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r7h3 = c >>> E.b; //ok +>r7h3 : number +>c >>> E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r7h4 = d >>> E.b; +>r7h4 : number +>d >>> E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r7h5 = e >>> E.b; +>r7h5 : number +>e >>> E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r7h6 = f >>> E.b; +>r7h6 : number +>f >>> E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator & +var r8a1 = a & a; //ok +>r8a1 : number +>a & a : number +>a : any +>a : any + +var r8a2 = a & b; +>r8a2 : number +>a & b : number +>a : any +>b : boolean + +var r8a3 = a & c; //ok +>r8a3 : number +>a & c : number +>a : any +>c : number + +var r8a4 = a & d; +>r8a4 : number +>a & d : number +>a : any +>d : string + +var r8a5 = a & e; +>r8a5 : number +>a & e : number +>a : any +>e : { a: number; } + +var r8a6 = a & f; +>r8a6 : number +>a & f : number +>a : any +>f : Number + +var r8b1 = b & a; +>r8b1 : number +>b & a : number +>b : boolean +>a : any + +var r8b2 = b & b; +>r8b2 : number +>b & b : number +>b : boolean +>b : boolean + +var r8b3 = b & c; +>r8b3 : number +>b & c : number +>b : boolean +>c : number + +var r8b4 = b & d; +>r8b4 : number +>b & d : number +>b : boolean +>d : string + +var r8b5 = b & e; +>r8b5 : number +>b & e : number +>b : boolean +>e : { a: number; } + +var r8b6 = b & f; +>r8b6 : number +>b & f : number +>b : boolean +>f : Number + +var r8c1 = c & a; //ok +>r8c1 : number +>c & a : number +>c : number +>a : any + +var r8c2 = c & b; +>r8c2 : number +>c & b : number +>c : number +>b : boolean + +var r8c3 = c & c; //ok +>r8c3 : number +>c & c : number +>c : number +>c : number + +var r8c4 = c & d; +>r8c4 : number +>c & d : number +>c : number +>d : string + +var r8c5 = c & e; +>r8c5 : number +>c & e : number +>c : number +>e : { a: number; } + +var r8c6 = c & f; +>r8c6 : number +>c & f : number +>c : number +>f : Number + +var r8d1 = d & a; +>r8d1 : number +>d & a : number +>d : string +>a : any + +var r8d2 = d & b; +>r8d2 : number +>d & b : number +>d : string +>b : boolean + +var r8d3 = d & c; +>r8d3 : number +>d & c : number +>d : string +>c : number + +var r8d4 = d & d; +>r8d4 : number +>d & d : number +>d : string +>d : string + +var r8d5 = d & e; +>r8d5 : number +>d & e : number +>d : string +>e : { a: number; } + +var r8d6 = d & f; +>r8d6 : number +>d & f : number +>d : string +>f : Number + +var r8e1 = e & a; +>r8e1 : number +>e & a : number +>e : { a: number; } +>a : any + +var r8e2 = e & b; +>r8e2 : number +>e & b : number +>e : { a: number; } +>b : boolean + +var r8e3 = e & c; +>r8e3 : number +>e & c : number +>e : { a: number; } +>c : number + +var r8e4 = e & d; +>r8e4 : number +>e & d : number +>e : { a: number; } +>d : string + +var r8e5 = e & e; +>r8e5 : number +>e & e : number +>e : { a: number; } +>e : { a: number; } + +var r8e6 = e & f; +>r8e6 : number +>e & f : number +>e : { a: number; } +>f : Number + +var r8f1 = f & a; +>r8f1 : number +>f & a : number +>f : Number +>a : any + +var r8f2 = f & b; +>r8f2 : number +>f & b : number +>f : Number +>b : boolean + +var r8f3 = f & c; +>r8f3 : number +>f & c : number +>f : Number +>c : number + +var r8f4 = f & d; +>r8f4 : number +>f & d : number +>f : Number +>d : string + +var r8f5 = f & e; +>r8f5 : number +>f & e : number +>f : Number +>e : { a: number; } + +var r8f6 = f & f; +>r8f6 : number +>f & f : number +>f : Number +>f : Number + +var r8g1 = E.a & a; //ok +>r8g1 : number +>E.a & a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r8g2 = E.a & b; +>r8g2 : number +>E.a & b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r8g3 = E.a & c; //ok +>r8g3 : number +>E.a & c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r8g4 = E.a & d; +>r8g4 : number +>E.a & d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r8g5 = E.a & e; +>r8g5 : number +>E.a & e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r8g6 = E.a & f; +>r8g6 : number +>E.a & f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r8h1 = a & E.b; //ok +>r8h1 : number +>a & E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r8h2 = b & E.b; +>r8h2 : number +>b & E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r8h3 = c & E.b; //ok +>r8h3 : number +>c & E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r8h4 = d & E.b; +>r8h4 : number +>d & E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r8h5 = e & E.b; +>r8h5 : number +>e & E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r8h6 = f & E.b; +>r8h6 : number +>f & E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator ^ +var r9a1 = a ^ a; //ok +>r9a1 : number +>a ^ a : number +>a : any +>a : any + +var r9a2 = a ^ b; +>r9a2 : number +>a ^ b : number +>a : any +>b : boolean + +var r9a3 = a ^ c; //ok +>r9a3 : number +>a ^ c : number +>a : any +>c : number + +var r9a4 = a ^ d; +>r9a4 : number +>a ^ d : number +>a : any +>d : string + +var r9a5 = a ^ e; +>r9a5 : number +>a ^ e : number +>a : any +>e : { a: number; } + +var r9a6 = a ^ f; +>r9a6 : number +>a ^ f : number +>a : any +>f : Number + +var r9b1 = b ^ a; +>r9b1 : number +>b ^ a : number +>b : boolean +>a : any + +var r9b2 = b ^ b; +>r9b2 : number +>b ^ b : number +>b : boolean +>b : boolean + +var r9b3 = b ^ c; +>r9b3 : number +>b ^ c : number +>b : boolean +>c : number + +var r9b4 = b ^ d; +>r9b4 : number +>b ^ d : number +>b : boolean +>d : string + +var r9b5 = b ^ e; +>r9b5 : number +>b ^ e : number +>b : boolean +>e : { a: number; } + +var r9b6 = b ^ f; +>r9b6 : number +>b ^ f : number +>b : boolean +>f : Number + +var r9c1 = c ^ a; //ok +>r9c1 : number +>c ^ a : number +>c : number +>a : any + +var r9c2 = c ^ b; +>r9c2 : number +>c ^ b : number +>c : number +>b : boolean + +var r9c3 = c ^ c; //ok +>r9c3 : number +>c ^ c : number +>c : number +>c : number + +var r9c4 = c ^ d; +>r9c4 : number +>c ^ d : number +>c : number +>d : string + +var r9c5 = c ^ e; +>r9c5 : number +>c ^ e : number +>c : number +>e : { a: number; } + +var r9c6 = c ^ f; +>r9c6 : number +>c ^ f : number +>c : number +>f : Number + +var r9d1 = d ^ a; +>r9d1 : number +>d ^ a : number +>d : string +>a : any + +var r9d2 = d ^ b; +>r9d2 : number +>d ^ b : number +>d : string +>b : boolean + +var r9d3 = d ^ c; +>r9d3 : number +>d ^ c : number +>d : string +>c : number + +var r9d4 = d ^ d; +>r9d4 : number +>d ^ d : number +>d : string +>d : string + +var r9d5 = d ^ e; +>r9d5 : number +>d ^ e : number +>d : string +>e : { a: number; } + +var r9d6 = d ^ f; +>r9d6 : number +>d ^ f : number +>d : string +>f : Number + +var r9e1 = e ^ a; +>r9e1 : number +>e ^ a : number +>e : { a: number; } +>a : any + +var r9e2 = e ^ b; +>r9e2 : number +>e ^ b : number +>e : { a: number; } +>b : boolean + +var r9e3 = e ^ c; +>r9e3 : number +>e ^ c : number +>e : { a: number; } +>c : number + +var r9e4 = e ^ d; +>r9e4 : number +>e ^ d : number +>e : { a: number; } +>d : string + +var r9e5 = e ^ e; +>r9e5 : number +>e ^ e : number +>e : { a: number; } +>e : { a: number; } + +var r9e6 = e ^ f; +>r9e6 : number +>e ^ f : number +>e : { a: number; } +>f : Number + +var r9f1 = f ^ a; +>r9f1 : number +>f ^ a : number +>f : Number +>a : any + +var r9f2 = f ^ b; +>r9f2 : number +>f ^ b : number +>f : Number +>b : boolean + +var r9f3 = f ^ c; +>r9f3 : number +>f ^ c : number +>f : Number +>c : number + +var r9f4 = f ^ d; +>r9f4 : number +>f ^ d : number +>f : Number +>d : string + +var r9f5 = f ^ e; +>r9f5 : number +>f ^ e : number +>f : Number +>e : { a: number; } + +var r9f6 = f ^ f; +>r9f6 : number +>f ^ f : number +>f : Number +>f : Number + +var r9g1 = E.a ^ a; //ok +>r9g1 : number +>E.a ^ a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r9g2 = E.a ^ b; +>r9g2 : number +>E.a ^ b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r9g3 = E.a ^ c; //ok +>r9g3 : number +>E.a ^ c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r9g4 = E.a ^ d; +>r9g4 : number +>E.a ^ d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r9g5 = E.a ^ e; +>r9g5 : number +>E.a ^ e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r9g6 = E.a ^ f; +>r9g6 : number +>E.a ^ f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r9h1 = a ^ E.b; //ok +>r9h1 : number +>a ^ E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r9h2 = b ^ E.b; +>r9h2 : number +>b ^ E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r9h3 = c ^ E.b; //ok +>r9h3 : number +>c ^ E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r9h4 = d ^ E.b; +>r9h4 : number +>d ^ E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r9h5 = e ^ E.b; +>r9h5 : number +>e ^ E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r9h6 = f ^ E.b; +>r9h6 : number +>f ^ E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + +// operator | +var r10a1 = a | a; //ok +>r10a1 : number +>a | a : number +>a : any +>a : any + +var r10a2 = a | b; +>r10a2 : number +>a | b : number +>a : any +>b : boolean + +var r10a3 = a | c; //ok +>r10a3 : number +>a | c : number +>a : any +>c : number + +var r10a4 = a | d; +>r10a4 : number +>a | d : number +>a : any +>d : string + +var r10a5 = a | e; +>r10a5 : number +>a | e : number +>a : any +>e : { a: number; } + +var r10a6 = a | f; +>r10a6 : number +>a | f : number +>a : any +>f : Number + +var r10b1 = b | a; +>r10b1 : number +>b | a : number +>b : boolean +>a : any + +var r10b2 = b | b; +>r10b2 : number +>b | b : number +>b : boolean +>b : boolean + +var r10b3 = b | c; +>r10b3 : number +>b | c : number +>b : boolean +>c : number + +var r10b4 = b | d; +>r10b4 : number +>b | d : number +>b : boolean +>d : string + +var r10b5 = b | e; +>r10b5 : number +>b | e : number +>b : boolean +>e : { a: number; } + +var r10b6 = b | f; +>r10b6 : number +>b | f : number +>b : boolean +>f : Number + +var r10c1 = c | a; //ok +>r10c1 : number +>c | a : number +>c : number +>a : any + +var r10c2 = c | b; +>r10c2 : number +>c | b : number +>c : number +>b : boolean + +var r10c3 = c | c; //ok +>r10c3 : number +>c | c : number +>c : number +>c : number + +var r10c4 = c | d; +>r10c4 : number +>c | d : number +>c : number +>d : string + +var r10c5 = c | e; +>r10c5 : number +>c | e : number +>c : number +>e : { a: number; } + +var r10c6 = c | f; +>r10c6 : number +>c | f : number +>c : number +>f : Number + +var r10d1 = d | a; +>r10d1 : number +>d | a : number +>d : string +>a : any + +var r10d2 = d | b; +>r10d2 : number +>d | b : number +>d : string +>b : boolean + +var r10d3 = d | c; +>r10d3 : number +>d | c : number +>d : string +>c : number + +var r10d4 = d | d; +>r10d4 : number +>d | d : number +>d : string +>d : string + +var r10d5 = d | e; +>r10d5 : number +>d | e : number +>d : string +>e : { a: number; } + +var r10d6 = d | f; +>r10d6 : number +>d | f : number +>d : string +>f : Number + +var r10e1 = e | a; +>r10e1 : number +>e | a : number +>e : { a: number; } +>a : any + +var r10e2 = e | b; +>r10e2 : number +>e | b : number +>e : { a: number; } +>b : boolean + +var r10e3 = e | c; +>r10e3 : number +>e | c : number +>e : { a: number; } +>c : number + +var r10e4 = e | d; +>r10e4 : number +>e | d : number +>e : { a: number; } +>d : string + +var r10e5 = e | e; +>r10e5 : number +>e | e : number +>e : { a: number; } +>e : { a: number; } + +var r10e6 = e | f; +>r10e6 : number +>e | f : number +>e : { a: number; } +>f : Number + +var r10f1 = f | a; +>r10f1 : number +>f | a : number +>f : Number +>a : any + +var r10f2 = f | b; +>r10f2 : number +>f | b : number +>f : Number +>b : boolean + +var r10f3 = f | c; +>r10f3 : number +>f | c : number +>f : Number +>c : number + +var r10f4 = f | d; +>r10f4 : number +>f | d : number +>f : Number +>d : string + +var r10f5 = f | e; +>r10f5 : number +>f | e : number +>f : Number +>e : { a: number; } + +var r10f6 = f | f; +>r10f6 : number +>f | f : number +>f : Number +>f : Number + +var r10g1 = E.a | a; //ok +>r10g1 : number +>E.a | a : number +>E.a : E.a +>E : typeof E +>a : E.a +>a : any + +var r10g2 = E.a | b; +>r10g2 : number +>E.a | b : number +>E.a : E.a +>E : typeof E +>a : E.a +>b : boolean + +var r10g3 = E.a | c; //ok +>r10g3 : number +>E.a | c : number +>E.a : E.a +>E : typeof E +>a : E.a +>c : number + +var r10g4 = E.a | d; +>r10g4 : number +>E.a | d : number +>E.a : E.a +>E : typeof E +>a : E.a +>d : string + +var r10g5 = E.a | e; +>r10g5 : number +>E.a | e : number +>E.a : E.a +>E : typeof E +>a : E.a +>e : { a: number; } + +var r10g6 = E.a | f; +>r10g6 : number +>E.a | f : number +>E.a : E.a +>E : typeof E +>a : E.a +>f : Number + +var r10h1 = a | E.b; //ok +>r10h1 : number +>a | E.b : number +>a : any +>E.b : E.b +>E : typeof E +>b : E.b + +var r10h2 = b | E.b; +>r10h2 : number +>b | E.b : number +>b : boolean +>E.b : E.b +>E : typeof E +>b : E.b + +var r10h3 = c | E.b; //ok +>r10h3 : number +>c | E.b : number +>c : number +>E.b : E.b +>E : typeof E +>b : E.b + +var r10h4 = d | E.b; +>r10h4 : number +>d | E.b : number +>d : string +>E.b : E.b +>E : typeof E +>b : E.b + +var r10h5 = e | E.b; +>r10h5 : number +>e | E.b : number +>e : { a: number; } +>E.b : E.b +>E : typeof E +>b : E.b + +var r10h6 = f | E.b; +>r10h6 : number +>f | E.b : number +>f : Number +>E.b : E.b +>E : typeof E +>b : E.b + diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols new file mode 100644 index 00000000000..7e55e3c0052 --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.symbols @@ -0,0 +1,444 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts === +// If one operand is the null or undefined value, it is treated as having the type of the +// other operand. + +var a: boolean; +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var b: string; +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var c: Object; +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +// operator * +var r1a1 = null * a; +>r1a1 : Symbol(r1a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 8, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r1a2 = null * b; +>r1a2 : Symbol(r1a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 9, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r1a3 = null * c; +>r1a3 : Symbol(r1a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 10, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r1b1 = a * null; +>r1b1 : Symbol(r1b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 12, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r1b2 = b * null; +>r1b2 : Symbol(r1b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 13, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r1b3 = c * null; +>r1b3 : Symbol(r1b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 14, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r1c1 = null * true; +>r1c1 : Symbol(r1c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 16, 3)) + +var r1c2 = null * ''; +>r1c2 : Symbol(r1c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 17, 3)) + +var r1c3 = null * {}; +>r1c3 : Symbol(r1c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 18, 3)) + +var r1d1 = true * null; +>r1d1 : Symbol(r1d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 20, 3)) + +var r1d2 = '' * null; +>r1d2 : Symbol(r1d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 21, 3)) + +var r1d3 = {} * null; +>r1d3 : Symbol(r1d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 22, 3)) + +// operator / +var r2a1 = null / a; +>r2a1 : Symbol(r2a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 25, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r2a2 = null / b; +>r2a2 : Symbol(r2a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 26, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r2a3 = null / c; +>r2a3 : Symbol(r2a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 27, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r2b1 = a / null; +>r2b1 : Symbol(r2b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 29, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r2b2 = b / null; +>r2b2 : Symbol(r2b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 30, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r2b3 = c / null; +>r2b3 : Symbol(r2b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 31, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r2c1 = null / true; +>r2c1 : Symbol(r2c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 33, 3)) + +var r2c2 = null / ''; +>r2c2 : Symbol(r2c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 34, 3)) + +var r2c3 = null / {}; +>r2c3 : Symbol(r2c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 35, 3)) + +var r2d1 = true / null; +>r2d1 : Symbol(r2d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 37, 3)) + +var r2d2 = '' / null; +>r2d2 : Symbol(r2d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 38, 3)) + +var r2d3 = {} / null; +>r2d3 : Symbol(r2d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 39, 3)) + +// operator % +var r3a1 = null % a; +>r3a1 : Symbol(r3a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 42, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r3a2 = null % b; +>r3a2 : Symbol(r3a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 43, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r3a3 = null % c; +>r3a3 : Symbol(r3a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 44, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r3b1 = a % null; +>r3b1 : Symbol(r3b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 46, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r3b2 = b % null; +>r3b2 : Symbol(r3b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 47, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r3b3 = c % null; +>r3b3 : Symbol(r3b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 48, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r3c1 = null % true; +>r3c1 : Symbol(r3c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 50, 3)) + +var r3c2 = null % ''; +>r3c2 : Symbol(r3c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 51, 3)) + +var r3c3 = null % {}; +>r3c3 : Symbol(r3c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 52, 3)) + +var r3d1 = true % null; +>r3d1 : Symbol(r3d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 54, 3)) + +var r3d2 = '' % null; +>r3d2 : Symbol(r3d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 55, 3)) + +var r3d3 = {} % null; +>r3d3 : Symbol(r3d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 56, 3)) + +// operator - +var r4a1 = null - a; +>r4a1 : Symbol(r4a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 59, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r4a2 = null - b; +>r4a2 : Symbol(r4a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 60, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r4a3 = null - c; +>r4a3 : Symbol(r4a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 61, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r4b1 = a - null; +>r4b1 : Symbol(r4b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 63, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r4b2 = b - null; +>r4b2 : Symbol(r4b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 64, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r4b3 = c - null; +>r4b3 : Symbol(r4b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 65, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r4c1 = null - true; +>r4c1 : Symbol(r4c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 67, 3)) + +var r4c2 = null - ''; +>r4c2 : Symbol(r4c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 68, 3)) + +var r4c3 = null - {}; +>r4c3 : Symbol(r4c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 69, 3)) + +var r4d1 = true - null; +>r4d1 : Symbol(r4d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 71, 3)) + +var r4d2 = '' - null; +>r4d2 : Symbol(r4d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 72, 3)) + +var r4d3 = {} - null; +>r4d3 : Symbol(r4d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 73, 3)) + +// operator << +var r5a1 = null << a; +>r5a1 : Symbol(r5a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 76, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r5a2 = null << b; +>r5a2 : Symbol(r5a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 77, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r5a3 = null << c; +>r5a3 : Symbol(r5a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 78, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r5b1 = a << null; +>r5b1 : Symbol(r5b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 80, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r5b2 = b << null; +>r5b2 : Symbol(r5b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 81, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r5b3 = c << null; +>r5b3 : Symbol(r5b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 82, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r5c1 = null << true; +>r5c1 : Symbol(r5c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 84, 3)) + +var r5c2 = null << ''; +>r5c2 : Symbol(r5c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 85, 3)) + +var r5c3 = null << {}; +>r5c3 : Symbol(r5c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 86, 3)) + +var r5d1 = true << null; +>r5d1 : Symbol(r5d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 88, 3)) + +var r5d2 = '' << null; +>r5d2 : Symbol(r5d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 89, 3)) + +var r5d3 = {} << null; +>r5d3 : Symbol(r5d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 90, 3)) + +// operator >> +var r6a1 = null >> a; +>r6a1 : Symbol(r6a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 93, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r6a2 = null >> b; +>r6a2 : Symbol(r6a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 94, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r6a3 = null >> c; +>r6a3 : Symbol(r6a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 95, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r6b1 = a >> null; +>r6b1 : Symbol(r6b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 97, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r6b2 = b >> null; +>r6b2 : Symbol(r6b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 98, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r6b3 = c >> null; +>r6b3 : Symbol(r6b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 99, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r6c1 = null >> true; +>r6c1 : Symbol(r6c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 101, 3)) + +var r6c2 = null >> ''; +>r6c2 : Symbol(r6c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 102, 3)) + +var r6c3 = null >> {}; +>r6c3 : Symbol(r6c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 103, 3)) + +var r6d1 = true >> null; +>r6d1 : Symbol(r6d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 105, 3)) + +var r6d2 = '' >> null; +>r6d2 : Symbol(r6d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 106, 3)) + +var r6d3 = {} >> null; +>r6d3 : Symbol(r6d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 107, 3)) + +// operator >>> +var r7a1 = null >>> a; +>r7a1 : Symbol(r7a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 110, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r7a2 = null >>> b; +>r7a2 : Symbol(r7a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 111, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r7a3 = null >>> c; +>r7a3 : Symbol(r7a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 112, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r7b1 = a >>> null; +>r7b1 : Symbol(r7b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 114, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r7b2 = b >>> null; +>r7b2 : Symbol(r7b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 115, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r7b3 = c >>> null; +>r7b3 : Symbol(r7b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 116, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r7c1 = null >>> true; +>r7c1 : Symbol(r7c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 118, 3)) + +var r7c2 = null >>> ''; +>r7c2 : Symbol(r7c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 119, 3)) + +var r7c3 = null >>> {}; +>r7c3 : Symbol(r7c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 120, 3)) + +var r7d1 = true >>> null; +>r7d1 : Symbol(r7d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 122, 3)) + +var r7d2 = '' >>> null; +>r7d2 : Symbol(r7d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 123, 3)) + +var r7d3 = {} >>> null; +>r7d3 : Symbol(r7d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 124, 3)) + +// operator & +var r8a1 = null & a; +>r8a1 : Symbol(r8a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 127, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r8a2 = null & b; +>r8a2 : Symbol(r8a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 128, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r8a3 = null & c; +>r8a3 : Symbol(r8a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 129, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r8b1 = a & null; +>r8b1 : Symbol(r8b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 131, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r8b2 = b & null; +>r8b2 : Symbol(r8b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 132, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r8b3 = c & null; +>r8b3 : Symbol(r8b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 133, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r8c1 = null & true; +>r8c1 : Symbol(r8c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 135, 3)) + +var r8c2 = null & ''; +>r8c2 : Symbol(r8c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 136, 3)) + +var r8c3 = null & {}; +>r8c3 : Symbol(r8c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 137, 3)) + +var r8d1 = true & null; +>r8d1 : Symbol(r8d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 139, 3)) + +var r8d2 = '' & null; +>r8d2 : Symbol(r8d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 140, 3)) + +var r8d3 = {} & null; +>r8d3 : Symbol(r8d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 141, 3)) + +// operator ^ +var r9a1 = null ^ a; +>r9a1 : Symbol(r9a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 144, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r9a2 = null ^ b; +>r9a2 : Symbol(r9a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 145, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r9a3 = null ^ c; +>r9a3 : Symbol(r9a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 146, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r9b1 = a ^ null; +>r9b1 : Symbol(r9b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 148, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r9b2 = b ^ null; +>r9b2 : Symbol(r9b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 149, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r9b3 = c ^ null; +>r9b3 : Symbol(r9b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 150, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r9c1 = null ^ true; +>r9c1 : Symbol(r9c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 152, 3)) + +var r9c2 = null ^ ''; +>r9c2 : Symbol(r9c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 153, 3)) + +var r9c3 = null ^ {}; +>r9c3 : Symbol(r9c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 154, 3)) + +var r9d1 = true ^ null; +>r9d1 : Symbol(r9d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 156, 3)) + +var r9d2 = '' ^ null; +>r9d2 : Symbol(r9d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 157, 3)) + +var r9d3 = {} ^ null; +>r9d3 : Symbol(r9d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 158, 3)) + +// operator | +var r10a1 = null | a; +>r10a1 : Symbol(r10a1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 161, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r10a2 = null | b; +>r10a2 : Symbol(r10a2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 162, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r10a3 = null | c; +>r10a3 : Symbol(r10a3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 163, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r10b1 = a | null; +>r10b1 : Symbol(r10b1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 165, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 3, 3)) + +var r10b2 = b | null; +>r10b2 : Symbol(r10b2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 166, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 4, 3)) + +var r10b3 = c | null; +>r10b3 : Symbol(r10b3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 167, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 5, 3)) + +var r10c1 = null | true; +>r10c1 : Symbol(r10c1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 169, 3)) + +var r10c2 = null | ''; +>r10c2 : Symbol(r10c2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 170, 3)) + +var r10c3 = null | {}; +>r10c3 : Symbol(r10c3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 171, 3)) + +var r10d1 = true | null; +>r10d1 : Symbol(r10d1, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 173, 3)) + +var r10d2 = '' | null; +>r10d2 : Symbol(r10d2, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 174, 3)) + +var r10d3 = {} | null; +>r10d3 : Symbol(r10d3, Decl(arithmeticOperatorWithNullValueAndInvalidOperands.ts, 175, 3)) + diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types new file mode 100644 index 00000000000..2a0fb6d9239 --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndInvalidOperands.types @@ -0,0 +1,744 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndInvalidOperands.ts === +// If one operand is the null or undefined value, it is treated as having the type of the +// other operand. + +var a: boolean; +>a : boolean + +var b: string; +>b : string + +var c: Object; +>c : Object +>Object : Object + +// operator * +var r1a1 = null * a; +>r1a1 : number +>null * a : number +>null : null +>a : boolean + +var r1a2 = null * b; +>r1a2 : number +>null * b : number +>null : null +>b : string + +var r1a3 = null * c; +>r1a3 : number +>null * c : number +>null : null +>c : Object + +var r1b1 = a * null; +>r1b1 : number +>a * null : number +>a : boolean +>null : null + +var r1b2 = b * null; +>r1b2 : number +>b * null : number +>b : string +>null : null + +var r1b3 = c * null; +>r1b3 : number +>c * null : number +>c : Object +>null : null + +var r1c1 = null * true; +>r1c1 : number +>null * true : number +>null : null +>true : true + +var r1c2 = null * ''; +>r1c2 : number +>null * '' : number +>null : null +>'' : "" + +var r1c3 = null * {}; +>r1c3 : number +>null * {} : number +>null : null +>{} : {} + +var r1d1 = true * null; +>r1d1 : number +>true * null : number +>true : true +>null : null + +var r1d2 = '' * null; +>r1d2 : number +>'' * null : number +>'' : "" +>null : null + +var r1d3 = {} * null; +>r1d3 : number +>{} * null : number +>{} : {} +>null : null + +// operator / +var r2a1 = null / a; +>r2a1 : number +>null / a : number +>null : null +>a : boolean + +var r2a2 = null / b; +>r2a2 : number +>null / b : number +>null : null +>b : string + +var r2a3 = null / c; +>r2a3 : number +>null / c : number +>null : null +>c : Object + +var r2b1 = a / null; +>r2b1 : number +>a / null : number +>a : boolean +>null : null + +var r2b2 = b / null; +>r2b2 : number +>b / null : number +>b : string +>null : null + +var r2b3 = c / null; +>r2b3 : number +>c / null : number +>c : Object +>null : null + +var r2c1 = null / true; +>r2c1 : number +>null / true : number +>null : null +>true : true + +var r2c2 = null / ''; +>r2c2 : number +>null / '' : number +>null : null +>'' : "" + +var r2c3 = null / {}; +>r2c3 : number +>null / {} : number +>null : null +>{} : {} + +var r2d1 = true / null; +>r2d1 : number +>true / null : number +>true : true +>null : null + +var r2d2 = '' / null; +>r2d2 : number +>'' / null : number +>'' : "" +>null : null + +var r2d3 = {} / null; +>r2d3 : number +>{} / null : number +>{} : {} +>null : null + +// operator % +var r3a1 = null % a; +>r3a1 : number +>null % a : number +>null : null +>a : boolean + +var r3a2 = null % b; +>r3a2 : number +>null % b : number +>null : null +>b : string + +var r3a3 = null % c; +>r3a3 : number +>null % c : number +>null : null +>c : Object + +var r3b1 = a % null; +>r3b1 : number +>a % null : number +>a : boolean +>null : null + +var r3b2 = b % null; +>r3b2 : number +>b % null : number +>b : string +>null : null + +var r3b3 = c % null; +>r3b3 : number +>c % null : number +>c : Object +>null : null + +var r3c1 = null % true; +>r3c1 : number +>null % true : number +>null : null +>true : true + +var r3c2 = null % ''; +>r3c2 : number +>null % '' : number +>null : null +>'' : "" + +var r3c3 = null % {}; +>r3c3 : number +>null % {} : number +>null : null +>{} : {} + +var r3d1 = true % null; +>r3d1 : number +>true % null : number +>true : true +>null : null + +var r3d2 = '' % null; +>r3d2 : number +>'' % null : number +>'' : "" +>null : null + +var r3d3 = {} % null; +>r3d3 : number +>{} % null : number +>{} : {} +>null : null + +// operator - +var r4a1 = null - a; +>r4a1 : number +>null - a : number +>null : null +>a : boolean + +var r4a2 = null - b; +>r4a2 : number +>null - b : number +>null : null +>b : string + +var r4a3 = null - c; +>r4a3 : number +>null - c : number +>null : null +>c : Object + +var r4b1 = a - null; +>r4b1 : number +>a - null : number +>a : boolean +>null : null + +var r4b2 = b - null; +>r4b2 : number +>b - null : number +>b : string +>null : null + +var r4b3 = c - null; +>r4b3 : number +>c - null : number +>c : Object +>null : null + +var r4c1 = null - true; +>r4c1 : number +>null - true : number +>null : null +>true : true + +var r4c2 = null - ''; +>r4c2 : number +>null - '' : number +>null : null +>'' : "" + +var r4c3 = null - {}; +>r4c3 : number +>null - {} : number +>null : null +>{} : {} + +var r4d1 = true - null; +>r4d1 : number +>true - null : number +>true : true +>null : null + +var r4d2 = '' - null; +>r4d2 : number +>'' - null : number +>'' : "" +>null : null + +var r4d3 = {} - null; +>r4d3 : number +>{} - null : number +>{} : {} +>null : null + +// operator << +var r5a1 = null << a; +>r5a1 : number +>null << a : number +>null : null +>a : boolean + +var r5a2 = null << b; +>r5a2 : number +>null << b : number +>null : null +>b : string + +var r5a3 = null << c; +>r5a3 : number +>null << c : number +>null : null +>c : Object + +var r5b1 = a << null; +>r5b1 : number +>a << null : number +>a : boolean +>null : null + +var r5b2 = b << null; +>r5b2 : number +>b << null : number +>b : string +>null : null + +var r5b3 = c << null; +>r5b3 : number +>c << null : number +>c : Object +>null : null + +var r5c1 = null << true; +>r5c1 : number +>null << true : number +>null : null +>true : true + +var r5c2 = null << ''; +>r5c2 : number +>null << '' : number +>null : null +>'' : "" + +var r5c3 = null << {}; +>r5c3 : number +>null << {} : number +>null : null +>{} : {} + +var r5d1 = true << null; +>r5d1 : number +>true << null : number +>true : true +>null : null + +var r5d2 = '' << null; +>r5d2 : number +>'' << null : number +>'' : "" +>null : null + +var r5d3 = {} << null; +>r5d3 : number +>{} << null : number +>{} : {} +>null : null + +// operator >> +var r6a1 = null >> a; +>r6a1 : number +>null >> a : number +>null : null +>a : boolean + +var r6a2 = null >> b; +>r6a2 : number +>null >> b : number +>null : null +>b : string + +var r6a3 = null >> c; +>r6a3 : number +>null >> c : number +>null : null +>c : Object + +var r6b1 = a >> null; +>r6b1 : number +>a >> null : number +>a : boolean +>null : null + +var r6b2 = b >> null; +>r6b2 : number +>b >> null : number +>b : string +>null : null + +var r6b3 = c >> null; +>r6b3 : number +>c >> null : number +>c : Object +>null : null + +var r6c1 = null >> true; +>r6c1 : number +>null >> true : number +>null : null +>true : true + +var r6c2 = null >> ''; +>r6c2 : number +>null >> '' : number +>null : null +>'' : "" + +var r6c3 = null >> {}; +>r6c3 : number +>null >> {} : number +>null : null +>{} : {} + +var r6d1 = true >> null; +>r6d1 : number +>true >> null : number +>true : true +>null : null + +var r6d2 = '' >> null; +>r6d2 : number +>'' >> null : number +>'' : "" +>null : null + +var r6d3 = {} >> null; +>r6d3 : number +>{} >> null : number +>{} : {} +>null : null + +// operator >>> +var r7a1 = null >>> a; +>r7a1 : number +>null >>> a : number +>null : null +>a : boolean + +var r7a2 = null >>> b; +>r7a2 : number +>null >>> b : number +>null : null +>b : string + +var r7a3 = null >>> c; +>r7a3 : number +>null >>> c : number +>null : null +>c : Object + +var r7b1 = a >>> null; +>r7b1 : number +>a >>> null : number +>a : boolean +>null : null + +var r7b2 = b >>> null; +>r7b2 : number +>b >>> null : number +>b : string +>null : null + +var r7b3 = c >>> null; +>r7b3 : number +>c >>> null : number +>c : Object +>null : null + +var r7c1 = null >>> true; +>r7c1 : number +>null >>> true : number +>null : null +>true : true + +var r7c2 = null >>> ''; +>r7c2 : number +>null >>> '' : number +>null : null +>'' : "" + +var r7c3 = null >>> {}; +>r7c3 : number +>null >>> {} : number +>null : null +>{} : {} + +var r7d1 = true >>> null; +>r7d1 : number +>true >>> null : number +>true : true +>null : null + +var r7d2 = '' >>> null; +>r7d2 : number +>'' >>> null : number +>'' : "" +>null : null + +var r7d3 = {} >>> null; +>r7d3 : number +>{} >>> null : number +>{} : {} +>null : null + +// operator & +var r8a1 = null & a; +>r8a1 : number +>null & a : number +>null : null +>a : boolean + +var r8a2 = null & b; +>r8a2 : number +>null & b : number +>null : null +>b : string + +var r8a3 = null & c; +>r8a3 : number +>null & c : number +>null : null +>c : Object + +var r8b1 = a & null; +>r8b1 : number +>a & null : number +>a : boolean +>null : null + +var r8b2 = b & null; +>r8b2 : number +>b & null : number +>b : string +>null : null + +var r8b3 = c & null; +>r8b3 : number +>c & null : number +>c : Object +>null : null + +var r8c1 = null & true; +>r8c1 : number +>null & true : number +>null : null +>true : true + +var r8c2 = null & ''; +>r8c2 : number +>null & '' : number +>null : null +>'' : "" + +var r8c3 = null & {}; +>r8c3 : number +>null & {} : number +>null : null +>{} : {} + +var r8d1 = true & null; +>r8d1 : number +>true & null : number +>true : true +>null : null + +var r8d2 = '' & null; +>r8d2 : number +>'' & null : number +>'' : "" +>null : null + +var r8d3 = {} & null; +>r8d3 : number +>{} & null : number +>{} : {} +>null : null + +// operator ^ +var r9a1 = null ^ a; +>r9a1 : number +>null ^ a : number +>null : null +>a : boolean + +var r9a2 = null ^ b; +>r9a2 : number +>null ^ b : number +>null : null +>b : string + +var r9a3 = null ^ c; +>r9a3 : number +>null ^ c : number +>null : null +>c : Object + +var r9b1 = a ^ null; +>r9b1 : number +>a ^ null : number +>a : boolean +>null : null + +var r9b2 = b ^ null; +>r9b2 : number +>b ^ null : number +>b : string +>null : null + +var r9b3 = c ^ null; +>r9b3 : number +>c ^ null : number +>c : Object +>null : null + +var r9c1 = null ^ true; +>r9c1 : number +>null ^ true : number +>null : null +>true : true + +var r9c2 = null ^ ''; +>r9c2 : number +>null ^ '' : number +>null : null +>'' : "" + +var r9c3 = null ^ {}; +>r9c3 : number +>null ^ {} : number +>null : null +>{} : {} + +var r9d1 = true ^ null; +>r9d1 : number +>true ^ null : number +>true : true +>null : null + +var r9d2 = '' ^ null; +>r9d2 : number +>'' ^ null : number +>'' : "" +>null : null + +var r9d3 = {} ^ null; +>r9d3 : number +>{} ^ null : number +>{} : {} +>null : null + +// operator | +var r10a1 = null | a; +>r10a1 : number +>null | a : number +>null : null +>a : boolean + +var r10a2 = null | b; +>r10a2 : number +>null | b : number +>null : null +>b : string + +var r10a3 = null | c; +>r10a3 : number +>null | c : number +>null : null +>c : Object + +var r10b1 = a | null; +>r10b1 : number +>a | null : number +>a : boolean +>null : null + +var r10b2 = b | null; +>r10b2 : number +>b | null : number +>b : string +>null : null + +var r10b3 = c | null; +>r10b3 : number +>c | null : number +>c : Object +>null : null + +var r10c1 = null | true; +>r10c1 : number +>null | true : number +>null : null +>true : true + +var r10c2 = null | ''; +>r10c2 : number +>null | '' : number +>null : null +>'' : "" + +var r10c3 = null | {}; +>r10c3 : number +>null | {} : number +>null : null +>{} : {} + +var r10d1 = true | null; +>r10d1 : number +>true | null : number +>true : true +>null : null + +var r10d2 = '' | null; +>r10d2 : number +>'' | null : number +>'' : "" +>null : null + +var r10d3 = {} | null; +>r10d3 : number +>{} | null : number +>{} : {} +>null : null + diff --git a/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.symbols b/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.symbols new file mode 100644 index 00000000000..4ee959cef79 --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.symbols @@ -0,0 +1,171 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts === +// operator * +var ra1 = null * null; +>ra1 : Symbol(ra1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 1, 3)) + +var ra2 = null * undefined; +>ra2 : Symbol(ra2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 2, 3)) +>undefined : Symbol(undefined) + +var ra3 = undefined * null; +>ra3 : Symbol(ra3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 3, 3)) +>undefined : Symbol(undefined) + +var ra4 = undefined * undefined; +>ra4 : Symbol(ra4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 4, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator / +var rb1 = null / null; +>rb1 : Symbol(rb1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 7, 3)) + +var rb2 = null / undefined; +>rb2 : Symbol(rb2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 8, 3)) +>undefined : Symbol(undefined) + +var rb3 = undefined / null; +>rb3 : Symbol(rb3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 9, 3)) +>undefined : Symbol(undefined) + +var rb4 = undefined / undefined; +>rb4 : Symbol(rb4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 10, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator % +var rc1 = null % null; +>rc1 : Symbol(rc1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 13, 3)) + +var rc2 = null % undefined; +>rc2 : Symbol(rc2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 14, 3)) +>undefined : Symbol(undefined) + +var rc3 = undefined % null; +>rc3 : Symbol(rc3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 15, 3)) +>undefined : Symbol(undefined) + +var rc4 = undefined % undefined; +>rc4 : Symbol(rc4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 16, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator - +var rd1 = null - null; +>rd1 : Symbol(rd1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 19, 3)) + +var rd2 = null - undefined; +>rd2 : Symbol(rd2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 20, 3)) +>undefined : Symbol(undefined) + +var rd3 = undefined - null; +>rd3 : Symbol(rd3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 21, 3)) +>undefined : Symbol(undefined) + +var rd4 = undefined - undefined; +>rd4 : Symbol(rd4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 22, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator << +var re1 = null << null; +>re1 : Symbol(re1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 25, 3)) + +var re2 = null << undefined; +>re2 : Symbol(re2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 26, 3)) +>undefined : Symbol(undefined) + +var re3 = undefined << null; +>re3 : Symbol(re3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 27, 3)) +>undefined : Symbol(undefined) + +var re4 = undefined << undefined; +>re4 : Symbol(re4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 28, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator >> +var rf1 = null >> null; +>rf1 : Symbol(rf1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 31, 3)) + +var rf2 = null >> undefined; +>rf2 : Symbol(rf2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 32, 3)) +>undefined : Symbol(undefined) + +var rf3 = undefined >> null; +>rf3 : Symbol(rf3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 33, 3)) +>undefined : Symbol(undefined) + +var rf4 = undefined >> undefined; +>rf4 : Symbol(rf4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 34, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator >>> +var rg1 = null >>> null; +>rg1 : Symbol(rg1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 37, 3)) + +var rg2 = null >>> undefined; +>rg2 : Symbol(rg2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 38, 3)) +>undefined : Symbol(undefined) + +var rg3 = undefined >>> null; +>rg3 : Symbol(rg3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 39, 3)) +>undefined : Symbol(undefined) + +var rg4 = undefined >>> undefined; +>rg4 : Symbol(rg4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 40, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator & +var rh1 = null & null; +>rh1 : Symbol(rh1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 43, 3)) + +var rh2 = null & undefined; +>rh2 : Symbol(rh2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 44, 3)) +>undefined : Symbol(undefined) + +var rh3 = undefined & null; +>rh3 : Symbol(rh3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 45, 3)) +>undefined : Symbol(undefined) + +var rh4 = undefined & undefined; +>rh4 : Symbol(rh4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 46, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator ^ +var ri1 = null ^ null; +>ri1 : Symbol(ri1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 49, 3)) + +var ri2 = null ^ undefined; +>ri2 : Symbol(ri2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 50, 3)) +>undefined : Symbol(undefined) + +var ri3 = undefined ^ null; +>ri3 : Symbol(ri3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 51, 3)) +>undefined : Symbol(undefined) + +var ri4 = undefined ^ undefined; +>ri4 : Symbol(ri4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 52, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// operator | +var rj1 = null | null; +>rj1 : Symbol(rj1, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 55, 3)) + +var rj2 = null | undefined; +>rj2 : Symbol(rj2, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 56, 3)) +>undefined : Symbol(undefined) + +var rj3 = undefined | null; +>rj3 : Symbol(rj3, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 57, 3)) +>undefined : Symbol(undefined) + +var rj4 = undefined | undefined; +>rj4 : Symbol(rj4, Decl(arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts, 58, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + diff --git a/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.types b/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.types new file mode 100644 index 00000000000..7b8963f4003 --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.types @@ -0,0 +1,251 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithOnlyNullValueOrUndefinedValue.ts === +// operator * +var ra1 = null * null; +>ra1 : number +>null * null : number +>null : null +>null : null + +var ra2 = null * undefined; +>ra2 : number +>null * undefined : number +>null : null +>undefined : undefined + +var ra3 = undefined * null; +>ra3 : number +>undefined * null : number +>undefined : undefined +>null : null + +var ra4 = undefined * undefined; +>ra4 : number +>undefined * undefined : number +>undefined : undefined +>undefined : undefined + +// operator / +var rb1 = null / null; +>rb1 : number +>null / null : number +>null : null +>null : null + +var rb2 = null / undefined; +>rb2 : number +>null / undefined : number +>null : null +>undefined : undefined + +var rb3 = undefined / null; +>rb3 : number +>undefined / null : number +>undefined : undefined +>null : null + +var rb4 = undefined / undefined; +>rb4 : number +>undefined / undefined : number +>undefined : undefined +>undefined : undefined + +// operator % +var rc1 = null % null; +>rc1 : number +>null % null : number +>null : null +>null : null + +var rc2 = null % undefined; +>rc2 : number +>null % undefined : number +>null : null +>undefined : undefined + +var rc3 = undefined % null; +>rc3 : number +>undefined % null : number +>undefined : undefined +>null : null + +var rc4 = undefined % undefined; +>rc4 : number +>undefined % undefined : number +>undefined : undefined +>undefined : undefined + +// operator - +var rd1 = null - null; +>rd1 : number +>null - null : number +>null : null +>null : null + +var rd2 = null - undefined; +>rd2 : number +>null - undefined : number +>null : null +>undefined : undefined + +var rd3 = undefined - null; +>rd3 : number +>undefined - null : number +>undefined : undefined +>null : null + +var rd4 = undefined - undefined; +>rd4 : number +>undefined - undefined : number +>undefined : undefined +>undefined : undefined + +// operator << +var re1 = null << null; +>re1 : number +>null << null : number +>null : null +>null : null + +var re2 = null << undefined; +>re2 : number +>null << undefined : number +>null : null +>undefined : undefined + +var re3 = undefined << null; +>re3 : number +>undefined << null : number +>undefined : undefined +>null : null + +var re4 = undefined << undefined; +>re4 : number +>undefined << undefined : number +>undefined : undefined +>undefined : undefined + +// operator >> +var rf1 = null >> null; +>rf1 : number +>null >> null : number +>null : null +>null : null + +var rf2 = null >> undefined; +>rf2 : number +>null >> undefined : number +>null : null +>undefined : undefined + +var rf3 = undefined >> null; +>rf3 : number +>undefined >> null : number +>undefined : undefined +>null : null + +var rf4 = undefined >> undefined; +>rf4 : number +>undefined >> undefined : number +>undefined : undefined +>undefined : undefined + +// operator >>> +var rg1 = null >>> null; +>rg1 : number +>null >>> null : number +>null : null +>null : null + +var rg2 = null >>> undefined; +>rg2 : number +>null >>> undefined : number +>null : null +>undefined : undefined + +var rg3 = undefined >>> null; +>rg3 : number +>undefined >>> null : number +>undefined : undefined +>null : null + +var rg4 = undefined >>> undefined; +>rg4 : number +>undefined >>> undefined : number +>undefined : undefined +>undefined : undefined + +// operator & +var rh1 = null & null; +>rh1 : number +>null & null : number +>null : null +>null : null + +var rh2 = null & undefined; +>rh2 : number +>null & undefined : number +>null : null +>undefined : undefined + +var rh3 = undefined & null; +>rh3 : number +>undefined & null : number +>undefined : undefined +>null : null + +var rh4 = undefined & undefined; +>rh4 : number +>undefined & undefined : number +>undefined : undefined +>undefined : undefined + +// operator ^ +var ri1 = null ^ null; +>ri1 : number +>null ^ null : number +>null : null +>null : null + +var ri2 = null ^ undefined; +>ri2 : number +>null ^ undefined : number +>null : null +>undefined : undefined + +var ri3 = undefined ^ null; +>ri3 : number +>undefined ^ null : number +>undefined : undefined +>null : null + +var ri4 = undefined ^ undefined; +>ri4 : number +>undefined ^ undefined : number +>undefined : undefined +>undefined : undefined + +// operator | +var rj1 = null | null; +>rj1 : number +>null | null : number +>null : null +>null : null + +var rj2 = null | undefined; +>rj2 : number +>null | undefined : number +>null : null +>undefined : undefined + +var rj3 = undefined | null; +>rj3 : number +>undefined | null : number +>undefined : undefined +>null : null + +var rj4 = undefined | undefined; +>rj4 : number +>undefined | undefined : number +>undefined : undefined +>undefined : undefined + diff --git a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols new file mode 100644 index 00000000000..24f058e530e --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.symbols @@ -0,0 +1,573 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithTypeParameter.ts === +// type parameter type is not valid for arithmetic operand +function foo(t: T) { +>foo : Symbol(foo, Decl(arithmeticOperatorWithTypeParameter.ts, 0, 0)) +>T : Symbol(T, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 13)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>T : Symbol(T, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 13)) + + var a: any; +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var b: boolean; +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var c: number; +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var d: string; +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var e: {}; +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r1a1 = a * t; +>r1a1 : Symbol(r1a1, Decl(arithmeticOperatorWithTypeParameter.ts, 8, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a2 = a / t; +>r1a2 : Symbol(r1a2, Decl(arithmeticOperatorWithTypeParameter.ts, 9, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a3 = a % t; +>r1a3 : Symbol(r1a3, Decl(arithmeticOperatorWithTypeParameter.ts, 10, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a4 = a - t; +>r1a4 : Symbol(r1a4, Decl(arithmeticOperatorWithTypeParameter.ts, 11, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a5 = a << t; +>r1a5 : Symbol(r1a5, Decl(arithmeticOperatorWithTypeParameter.ts, 12, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a6 = a >> t; +>r1a6 : Symbol(r1a6, Decl(arithmeticOperatorWithTypeParameter.ts, 13, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a7 = a >>> t; +>r1a7 : Symbol(r1a7, Decl(arithmeticOperatorWithTypeParameter.ts, 14, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a8 = a & t; +>r1a8 : Symbol(r1a8, Decl(arithmeticOperatorWithTypeParameter.ts, 15, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a9 = a ^ t; +>r1a9 : Symbol(r1a9, Decl(arithmeticOperatorWithTypeParameter.ts, 16, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1a10 = a | t; +>r1a10 : Symbol(r1a10, Decl(arithmeticOperatorWithTypeParameter.ts, 17, 7)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r2a1 = t * a; +>r2a1 : Symbol(r2a1, Decl(arithmeticOperatorWithTypeParameter.ts, 19, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a2 = t / a; +>r2a2 : Symbol(r2a2, Decl(arithmeticOperatorWithTypeParameter.ts, 20, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a3 = t % a; +>r2a3 : Symbol(r2a3, Decl(arithmeticOperatorWithTypeParameter.ts, 21, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a4 = t - a; +>r2a4 : Symbol(r2a4, Decl(arithmeticOperatorWithTypeParameter.ts, 22, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a5 = t << a; +>r2a5 : Symbol(r2a5, Decl(arithmeticOperatorWithTypeParameter.ts, 23, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a6 = t >> a; +>r2a6 : Symbol(r2a6, Decl(arithmeticOperatorWithTypeParameter.ts, 24, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a7 = t >>> a; +>r2a7 : Symbol(r2a7, Decl(arithmeticOperatorWithTypeParameter.ts, 25, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a8 = t & a; +>r2a8 : Symbol(r2a8, Decl(arithmeticOperatorWithTypeParameter.ts, 26, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a9 = t ^ a; +>r2a9 : Symbol(r2a9, Decl(arithmeticOperatorWithTypeParameter.ts, 27, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r2a10 = t | a; +>r2a10 : Symbol(r2a10, Decl(arithmeticOperatorWithTypeParameter.ts, 28, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>a : Symbol(a, Decl(arithmeticOperatorWithTypeParameter.ts, 2, 7)) + + var r1b1 = b * t; +>r1b1 : Symbol(r1b1, Decl(arithmeticOperatorWithTypeParameter.ts, 30, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b2 = b / t; +>r1b2 : Symbol(r1b2, Decl(arithmeticOperatorWithTypeParameter.ts, 31, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b3 = b % t; +>r1b3 : Symbol(r1b3, Decl(arithmeticOperatorWithTypeParameter.ts, 32, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b4 = b - t; +>r1b4 : Symbol(r1b4, Decl(arithmeticOperatorWithTypeParameter.ts, 33, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b5 = b << t; +>r1b5 : Symbol(r1b5, Decl(arithmeticOperatorWithTypeParameter.ts, 34, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b6 = b >> t; +>r1b6 : Symbol(r1b6, Decl(arithmeticOperatorWithTypeParameter.ts, 35, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b7 = b >>> t; +>r1b7 : Symbol(r1b7, Decl(arithmeticOperatorWithTypeParameter.ts, 36, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b8 = b & t; +>r1b8 : Symbol(r1b8, Decl(arithmeticOperatorWithTypeParameter.ts, 37, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b9 = b ^ t; +>r1b9 : Symbol(r1b9, Decl(arithmeticOperatorWithTypeParameter.ts, 38, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1b10 = b | t; +>r1b10 : Symbol(r1b10, Decl(arithmeticOperatorWithTypeParameter.ts, 39, 7)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r2b1 = t * b; +>r2b1 : Symbol(r2b1, Decl(arithmeticOperatorWithTypeParameter.ts, 41, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b2 = t / b; +>r2b2 : Symbol(r2b2, Decl(arithmeticOperatorWithTypeParameter.ts, 42, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b3 = t % b; +>r2b3 : Symbol(r2b3, Decl(arithmeticOperatorWithTypeParameter.ts, 43, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b4 = t - b; +>r2b4 : Symbol(r2b4, Decl(arithmeticOperatorWithTypeParameter.ts, 44, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b5 = t << b; +>r2b5 : Symbol(r2b5, Decl(arithmeticOperatorWithTypeParameter.ts, 45, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b6 = t >> b; +>r2b6 : Symbol(r2b6, Decl(arithmeticOperatorWithTypeParameter.ts, 46, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b7 = t >>> b; +>r2b7 : Symbol(r2b7, Decl(arithmeticOperatorWithTypeParameter.ts, 47, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b8 = t & b; +>r2b8 : Symbol(r2b8, Decl(arithmeticOperatorWithTypeParameter.ts, 48, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b9 = t ^ b; +>r2b9 : Symbol(r2b9, Decl(arithmeticOperatorWithTypeParameter.ts, 49, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r2b10 = t | b; +>r2b10 : Symbol(r2b10, Decl(arithmeticOperatorWithTypeParameter.ts, 50, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>b : Symbol(b, Decl(arithmeticOperatorWithTypeParameter.ts, 3, 7)) + + var r1c1 = c * t; +>r1c1 : Symbol(r1c1, Decl(arithmeticOperatorWithTypeParameter.ts, 52, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c2 = c / t; +>r1c2 : Symbol(r1c2, Decl(arithmeticOperatorWithTypeParameter.ts, 53, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c3 = c % t; +>r1c3 : Symbol(r1c3, Decl(arithmeticOperatorWithTypeParameter.ts, 54, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c4 = c - t; +>r1c4 : Symbol(r1c4, Decl(arithmeticOperatorWithTypeParameter.ts, 55, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c5 = c << t; +>r1c5 : Symbol(r1c5, Decl(arithmeticOperatorWithTypeParameter.ts, 56, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c6 = c >> t; +>r1c6 : Symbol(r1c6, Decl(arithmeticOperatorWithTypeParameter.ts, 57, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c7 = c >>> t; +>r1c7 : Symbol(r1c7, Decl(arithmeticOperatorWithTypeParameter.ts, 58, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c8 = c & t; +>r1c8 : Symbol(r1c8, Decl(arithmeticOperatorWithTypeParameter.ts, 59, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c9 = c ^ t; +>r1c9 : Symbol(r1c9, Decl(arithmeticOperatorWithTypeParameter.ts, 60, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1c10 = c | t; +>r1c10 : Symbol(r1c10, Decl(arithmeticOperatorWithTypeParameter.ts, 61, 7)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r2c1 = t * c; +>r2c1 : Symbol(r2c1, Decl(arithmeticOperatorWithTypeParameter.ts, 63, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c2 = t / c; +>r2c2 : Symbol(r2c2, Decl(arithmeticOperatorWithTypeParameter.ts, 64, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c3 = t % c; +>r2c3 : Symbol(r2c3, Decl(arithmeticOperatorWithTypeParameter.ts, 65, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c4 = t - c; +>r2c4 : Symbol(r2c4, Decl(arithmeticOperatorWithTypeParameter.ts, 66, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c5 = t << c; +>r2c5 : Symbol(r2c5, Decl(arithmeticOperatorWithTypeParameter.ts, 67, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c6 = t >> c; +>r2c6 : Symbol(r2c6, Decl(arithmeticOperatorWithTypeParameter.ts, 68, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c7 = t >>> c; +>r2c7 : Symbol(r2c7, Decl(arithmeticOperatorWithTypeParameter.ts, 69, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c8 = t & c; +>r2c8 : Symbol(r2c8, Decl(arithmeticOperatorWithTypeParameter.ts, 70, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c9 = t ^ c; +>r2c9 : Symbol(r2c9, Decl(arithmeticOperatorWithTypeParameter.ts, 71, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r2c10 = t | c; +>r2c10 : Symbol(r2c10, Decl(arithmeticOperatorWithTypeParameter.ts, 72, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>c : Symbol(c, Decl(arithmeticOperatorWithTypeParameter.ts, 4, 7)) + + var r1d1 = d * t; +>r1d1 : Symbol(r1d1, Decl(arithmeticOperatorWithTypeParameter.ts, 74, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d2 = d / t; +>r1d2 : Symbol(r1d2, Decl(arithmeticOperatorWithTypeParameter.ts, 75, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d3 = d % t; +>r1d3 : Symbol(r1d3, Decl(arithmeticOperatorWithTypeParameter.ts, 76, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d4 = d - t; +>r1d4 : Symbol(r1d4, Decl(arithmeticOperatorWithTypeParameter.ts, 77, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d5 = d << t; +>r1d5 : Symbol(r1d5, Decl(arithmeticOperatorWithTypeParameter.ts, 78, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d6 = d >> t; +>r1d6 : Symbol(r1d6, Decl(arithmeticOperatorWithTypeParameter.ts, 79, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d7 = d >>> t; +>r1d7 : Symbol(r1d7, Decl(arithmeticOperatorWithTypeParameter.ts, 80, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d8 = d & t; +>r1d8 : Symbol(r1d8, Decl(arithmeticOperatorWithTypeParameter.ts, 81, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d9 = d ^ t; +>r1d9 : Symbol(r1d9, Decl(arithmeticOperatorWithTypeParameter.ts, 82, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1d10 = d | t; +>r1d10 : Symbol(r1d10, Decl(arithmeticOperatorWithTypeParameter.ts, 83, 7)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r2d1 = t * d; +>r2d1 : Symbol(r2d1, Decl(arithmeticOperatorWithTypeParameter.ts, 85, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d2 = t / d; +>r2d2 : Symbol(r2d2, Decl(arithmeticOperatorWithTypeParameter.ts, 86, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d3 = t % d; +>r2d3 : Symbol(r2d3, Decl(arithmeticOperatorWithTypeParameter.ts, 87, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d4 = t - d; +>r2d4 : Symbol(r2d4, Decl(arithmeticOperatorWithTypeParameter.ts, 88, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d5 = t << d; +>r2d5 : Symbol(r2d5, Decl(arithmeticOperatorWithTypeParameter.ts, 89, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d6 = t >> d; +>r2d6 : Symbol(r2d6, Decl(arithmeticOperatorWithTypeParameter.ts, 90, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d7 = t >>> d; +>r2d7 : Symbol(r2d7, Decl(arithmeticOperatorWithTypeParameter.ts, 91, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d8 = t & d; +>r2d8 : Symbol(r2d8, Decl(arithmeticOperatorWithTypeParameter.ts, 92, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d9 = t ^ d; +>r2d9 : Symbol(r2d9, Decl(arithmeticOperatorWithTypeParameter.ts, 93, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r2d10 = t | d; +>r2d10 : Symbol(r2d10, Decl(arithmeticOperatorWithTypeParameter.ts, 94, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>d : Symbol(d, Decl(arithmeticOperatorWithTypeParameter.ts, 5, 7)) + + var r1e1 = e * t; +>r1e1 : Symbol(r1e1, Decl(arithmeticOperatorWithTypeParameter.ts, 96, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e2 = e / t; +>r1e2 : Symbol(r1e2, Decl(arithmeticOperatorWithTypeParameter.ts, 97, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e3 = e % t; +>r1e3 : Symbol(r1e3, Decl(arithmeticOperatorWithTypeParameter.ts, 98, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e4 = e - t; +>r1e4 : Symbol(r1e4, Decl(arithmeticOperatorWithTypeParameter.ts, 99, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e5 = e << t; +>r1e5 : Symbol(r1e5, Decl(arithmeticOperatorWithTypeParameter.ts, 100, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e6 = e >> t; +>r1e6 : Symbol(r1e6, Decl(arithmeticOperatorWithTypeParameter.ts, 101, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e7 = e >>> t; +>r1e7 : Symbol(r1e7, Decl(arithmeticOperatorWithTypeParameter.ts, 102, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e8 = e & t; +>r1e8 : Symbol(r1e8, Decl(arithmeticOperatorWithTypeParameter.ts, 103, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e9 = e ^ t; +>r1e9 : Symbol(r1e9, Decl(arithmeticOperatorWithTypeParameter.ts, 104, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1e10 = e | t; +>r1e10 : Symbol(r1e10, Decl(arithmeticOperatorWithTypeParameter.ts, 105, 7)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r2e1 = t * e; +>r2e1 : Symbol(r2e1, Decl(arithmeticOperatorWithTypeParameter.ts, 107, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e2 = t / e; +>r2e2 : Symbol(r2e2, Decl(arithmeticOperatorWithTypeParameter.ts, 108, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e3 = t % e; +>r2e3 : Symbol(r2e3, Decl(arithmeticOperatorWithTypeParameter.ts, 109, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e4 = t - e; +>r2e4 : Symbol(r2e4, Decl(arithmeticOperatorWithTypeParameter.ts, 110, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e5 = t << e; +>r2e5 : Symbol(r2e5, Decl(arithmeticOperatorWithTypeParameter.ts, 111, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e6 = t >> e; +>r2e6 : Symbol(r2e6, Decl(arithmeticOperatorWithTypeParameter.ts, 112, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e7 = t >>> e; +>r2e7 : Symbol(r2e7, Decl(arithmeticOperatorWithTypeParameter.ts, 113, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e8 = t & e; +>r2e8 : Symbol(r2e8, Decl(arithmeticOperatorWithTypeParameter.ts, 114, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e9 = t ^ e; +>r2e9 : Symbol(r2e9, Decl(arithmeticOperatorWithTypeParameter.ts, 115, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r2e10 = t | e; +>r2e10 : Symbol(r2e10, Decl(arithmeticOperatorWithTypeParameter.ts, 116, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>e : Symbol(e, Decl(arithmeticOperatorWithTypeParameter.ts, 6, 7)) + + var r1f1 = t * t; +>r1f1 : Symbol(r1f1, Decl(arithmeticOperatorWithTypeParameter.ts, 118, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f2 = t / t; +>r1f2 : Symbol(r1f2, Decl(arithmeticOperatorWithTypeParameter.ts, 119, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f3 = t % t; +>r1f3 : Symbol(r1f3, Decl(arithmeticOperatorWithTypeParameter.ts, 120, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f4 = t - t; +>r1f4 : Symbol(r1f4, Decl(arithmeticOperatorWithTypeParameter.ts, 121, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f5 = t << t; +>r1f5 : Symbol(r1f5, Decl(arithmeticOperatorWithTypeParameter.ts, 122, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f6 = t >> t; +>r1f6 : Symbol(r1f6, Decl(arithmeticOperatorWithTypeParameter.ts, 123, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f7 = t >>> t; +>r1f7 : Symbol(r1f7, Decl(arithmeticOperatorWithTypeParameter.ts, 124, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f8 = t & t; +>r1f8 : Symbol(r1f8, Decl(arithmeticOperatorWithTypeParameter.ts, 125, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f9 = t ^ t; +>r1f9 : Symbol(r1f9, Decl(arithmeticOperatorWithTypeParameter.ts, 126, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) + + var r1f10 = t | t; +>r1f10 : Symbol(r1f10, Decl(arithmeticOperatorWithTypeParameter.ts, 127, 7)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +>t : Symbol(t, Decl(arithmeticOperatorWithTypeParameter.ts, 1, 16)) +} diff --git a/tests/baselines/reference/arithmeticOperatorWithTypeParameter.types b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.types new file mode 100644 index 00000000000..0fc72d5dc0f --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithTypeParameter.types @@ -0,0 +1,683 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithTypeParameter.ts === +// type parameter type is not valid for arithmetic operand +function foo(t: T) { +>foo : (t: T) => void +>T : T +>t : T +>T : T + + var a: any; +>a : any + + var b: boolean; +>b : boolean + + var c: number; +>c : number + + var d: string; +>d : string + + var e: {}; +>e : {} + + var r1a1 = a * t; +>r1a1 : number +>a * t : number +>a : any +>t : T + + var r1a2 = a / t; +>r1a2 : number +>a / t : number +>a : any +>t : T + + var r1a3 = a % t; +>r1a3 : number +>a % t : number +>a : any +>t : T + + var r1a4 = a - t; +>r1a4 : number +>a - t : number +>a : any +>t : T + + var r1a5 = a << t; +>r1a5 : number +>a << t : number +>a : any +>t : T + + var r1a6 = a >> t; +>r1a6 : number +>a >> t : number +>a : any +>t : T + + var r1a7 = a >>> t; +>r1a7 : number +>a >>> t : number +>a : any +>t : T + + var r1a8 = a & t; +>r1a8 : number +>a & t : number +>a : any +>t : T + + var r1a9 = a ^ t; +>r1a9 : number +>a ^ t : number +>a : any +>t : T + + var r1a10 = a | t; +>r1a10 : number +>a | t : number +>a : any +>t : T + + var r2a1 = t * a; +>r2a1 : number +>t * a : number +>t : T +>a : any + + var r2a2 = t / a; +>r2a2 : number +>t / a : number +>t : T +>a : any + + var r2a3 = t % a; +>r2a3 : number +>t % a : number +>t : T +>a : any + + var r2a4 = t - a; +>r2a4 : number +>t - a : number +>t : T +>a : any + + var r2a5 = t << a; +>r2a5 : number +>t << a : number +>t : T +>a : any + + var r2a6 = t >> a; +>r2a6 : number +>t >> a : number +>t : T +>a : any + + var r2a7 = t >>> a; +>r2a7 : number +>t >>> a : number +>t : T +>a : any + + var r2a8 = t & a; +>r2a8 : number +>t & a : number +>t : T +>a : any + + var r2a9 = t ^ a; +>r2a9 : number +>t ^ a : number +>t : T +>a : any + + var r2a10 = t | a; +>r2a10 : number +>t | a : number +>t : T +>a : any + + var r1b1 = b * t; +>r1b1 : number +>b * t : number +>b : boolean +>t : T + + var r1b2 = b / t; +>r1b2 : number +>b / t : number +>b : boolean +>t : T + + var r1b3 = b % t; +>r1b3 : number +>b % t : number +>b : boolean +>t : T + + var r1b4 = b - t; +>r1b4 : number +>b - t : number +>b : boolean +>t : T + + var r1b5 = b << t; +>r1b5 : number +>b << t : number +>b : boolean +>t : T + + var r1b6 = b >> t; +>r1b6 : number +>b >> t : number +>b : boolean +>t : T + + var r1b7 = b >>> t; +>r1b7 : number +>b >>> t : number +>b : boolean +>t : T + + var r1b8 = b & t; +>r1b8 : number +>b & t : number +>b : boolean +>t : T + + var r1b9 = b ^ t; +>r1b9 : number +>b ^ t : number +>b : boolean +>t : T + + var r1b10 = b | t; +>r1b10 : number +>b | t : number +>b : boolean +>t : T + + var r2b1 = t * b; +>r2b1 : number +>t * b : number +>t : T +>b : boolean + + var r2b2 = t / b; +>r2b2 : number +>t / b : number +>t : T +>b : boolean + + var r2b3 = t % b; +>r2b3 : number +>t % b : number +>t : T +>b : boolean + + var r2b4 = t - b; +>r2b4 : number +>t - b : number +>t : T +>b : boolean + + var r2b5 = t << b; +>r2b5 : number +>t << b : number +>t : T +>b : boolean + + var r2b6 = t >> b; +>r2b6 : number +>t >> b : number +>t : T +>b : boolean + + var r2b7 = t >>> b; +>r2b7 : number +>t >>> b : number +>t : T +>b : boolean + + var r2b8 = t & b; +>r2b8 : number +>t & b : number +>t : T +>b : boolean + + var r2b9 = t ^ b; +>r2b9 : number +>t ^ b : number +>t : T +>b : boolean + + var r2b10 = t | b; +>r2b10 : number +>t | b : number +>t : T +>b : boolean + + var r1c1 = c * t; +>r1c1 : number +>c * t : number +>c : number +>t : T + + var r1c2 = c / t; +>r1c2 : number +>c / t : number +>c : number +>t : T + + var r1c3 = c % t; +>r1c3 : number +>c % t : number +>c : number +>t : T + + var r1c4 = c - t; +>r1c4 : number +>c - t : number +>c : number +>t : T + + var r1c5 = c << t; +>r1c5 : number +>c << t : number +>c : number +>t : T + + var r1c6 = c >> t; +>r1c6 : number +>c >> t : number +>c : number +>t : T + + var r1c7 = c >>> t; +>r1c7 : number +>c >>> t : number +>c : number +>t : T + + var r1c8 = c & t; +>r1c8 : number +>c & t : number +>c : number +>t : T + + var r1c9 = c ^ t; +>r1c9 : number +>c ^ t : number +>c : number +>t : T + + var r1c10 = c | t; +>r1c10 : number +>c | t : number +>c : number +>t : T + + var r2c1 = t * c; +>r2c1 : number +>t * c : number +>t : T +>c : number + + var r2c2 = t / c; +>r2c2 : number +>t / c : number +>t : T +>c : number + + var r2c3 = t % c; +>r2c3 : number +>t % c : number +>t : T +>c : number + + var r2c4 = t - c; +>r2c4 : number +>t - c : number +>t : T +>c : number + + var r2c5 = t << c; +>r2c5 : number +>t << c : number +>t : T +>c : number + + var r2c6 = t >> c; +>r2c6 : number +>t >> c : number +>t : T +>c : number + + var r2c7 = t >>> c; +>r2c7 : number +>t >>> c : number +>t : T +>c : number + + var r2c8 = t & c; +>r2c8 : number +>t & c : number +>t : T +>c : number + + var r2c9 = t ^ c; +>r2c9 : number +>t ^ c : number +>t : T +>c : number + + var r2c10 = t | c; +>r2c10 : number +>t | c : number +>t : T +>c : number + + var r1d1 = d * t; +>r1d1 : number +>d * t : number +>d : string +>t : T + + var r1d2 = d / t; +>r1d2 : number +>d / t : number +>d : string +>t : T + + var r1d3 = d % t; +>r1d3 : number +>d % t : number +>d : string +>t : T + + var r1d4 = d - t; +>r1d4 : number +>d - t : number +>d : string +>t : T + + var r1d5 = d << t; +>r1d5 : number +>d << t : number +>d : string +>t : T + + var r1d6 = d >> t; +>r1d6 : number +>d >> t : number +>d : string +>t : T + + var r1d7 = d >>> t; +>r1d7 : number +>d >>> t : number +>d : string +>t : T + + var r1d8 = d & t; +>r1d8 : number +>d & t : number +>d : string +>t : T + + var r1d9 = d ^ t; +>r1d9 : number +>d ^ t : number +>d : string +>t : T + + var r1d10 = d | t; +>r1d10 : number +>d | t : number +>d : string +>t : T + + var r2d1 = t * d; +>r2d1 : number +>t * d : number +>t : T +>d : string + + var r2d2 = t / d; +>r2d2 : number +>t / d : number +>t : T +>d : string + + var r2d3 = t % d; +>r2d3 : number +>t % d : number +>t : T +>d : string + + var r2d4 = t - d; +>r2d4 : number +>t - d : number +>t : T +>d : string + + var r2d5 = t << d; +>r2d5 : number +>t << d : number +>t : T +>d : string + + var r2d6 = t >> d; +>r2d6 : number +>t >> d : number +>t : T +>d : string + + var r2d7 = t >>> d; +>r2d7 : number +>t >>> d : number +>t : T +>d : string + + var r2d8 = t & d; +>r2d8 : number +>t & d : number +>t : T +>d : string + + var r2d9 = t ^ d; +>r2d9 : number +>t ^ d : number +>t : T +>d : string + + var r2d10 = t | d; +>r2d10 : number +>t | d : number +>t : T +>d : string + + var r1e1 = e * t; +>r1e1 : number +>e * t : number +>e : {} +>t : T + + var r1e2 = e / t; +>r1e2 : number +>e / t : number +>e : {} +>t : T + + var r1e3 = e % t; +>r1e3 : number +>e % t : number +>e : {} +>t : T + + var r1e4 = e - t; +>r1e4 : number +>e - t : number +>e : {} +>t : T + + var r1e5 = e << t; +>r1e5 : number +>e << t : number +>e : {} +>t : T + + var r1e6 = e >> t; +>r1e6 : number +>e >> t : number +>e : {} +>t : T + + var r1e7 = e >>> t; +>r1e7 : number +>e >>> t : number +>e : {} +>t : T + + var r1e8 = e & t; +>r1e8 : number +>e & t : number +>e : {} +>t : T + + var r1e9 = e ^ t; +>r1e9 : number +>e ^ t : number +>e : {} +>t : T + + var r1e10 = e | t; +>r1e10 : number +>e | t : number +>e : {} +>t : T + + var r2e1 = t * e; +>r2e1 : number +>t * e : number +>t : T +>e : {} + + var r2e2 = t / e; +>r2e2 : number +>t / e : number +>t : T +>e : {} + + var r2e3 = t % e; +>r2e3 : number +>t % e : number +>t : T +>e : {} + + var r2e4 = t - e; +>r2e4 : number +>t - e : number +>t : T +>e : {} + + var r2e5 = t << e; +>r2e5 : number +>t << e : number +>t : T +>e : {} + + var r2e6 = t >> e; +>r2e6 : number +>t >> e : number +>t : T +>e : {} + + var r2e7 = t >>> e; +>r2e7 : number +>t >>> e : number +>t : T +>e : {} + + var r2e8 = t & e; +>r2e8 : number +>t & e : number +>t : T +>e : {} + + var r2e9 = t ^ e; +>r2e9 : number +>t ^ e : number +>t : T +>e : {} + + var r2e10 = t | e; +>r2e10 : number +>t | e : number +>t : T +>e : {} + + var r1f1 = t * t; +>r1f1 : number +>t * t : number +>t : T +>t : T + + var r1f2 = t / t; +>r1f2 : number +>t / t : number +>t : T +>t : T + + var r1f3 = t % t; +>r1f3 : number +>t % t : number +>t : T +>t : T + + var r1f4 = t - t; +>r1f4 : number +>t - t : number +>t : T +>t : T + + var r1f5 = t << t; +>r1f5 : number +>t << t : number +>t : T +>t : T + + var r1f6 = t >> t; +>r1f6 : number +>t >> t : number +>t : T +>t : T + + var r1f7 = t >>> t; +>r1f7 : number +>t >>> t : number +>t : T +>t : T + + var r1f8 = t & t; +>r1f8 : number +>t & t : number +>t : T +>t : T + + var r1f9 = t ^ t; +>r1f9 : number +>t ^ t : number +>t : T +>t : T + + var r1f10 = t | t; +>r1f10 : number +>t | t : number +>t : T +>t : T +} diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols new file mode 100644 index 00000000000..8275cc2fed4 --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.symbols @@ -0,0 +1,564 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts === +// If one operand is the undefined or undefined value, it is treated as having the type of the +// other operand. + +var a: boolean; +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var b: string; +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var c: Object; +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +// operator * +var r1a1 = undefined * a; +>r1a1 : Symbol(r1a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 8, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r1a2 = undefined * b; +>r1a2 : Symbol(r1a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 9, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r1a3 = undefined * c; +>r1a3 : Symbol(r1a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 10, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r1b1 = a * undefined; +>r1b1 : Symbol(r1b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 12, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r1b2 = b * undefined; +>r1b2 : Symbol(r1b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 13, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r1b3 = c * undefined; +>r1b3 : Symbol(r1b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 14, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r1c1 = undefined * true; +>r1c1 : Symbol(r1c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 16, 3)) +>undefined : Symbol(undefined) + +var r1c2 = undefined * ''; +>r1c2 : Symbol(r1c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 17, 3)) +>undefined : Symbol(undefined) + +var r1c3 = undefined * {}; +>r1c3 : Symbol(r1c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 18, 3)) +>undefined : Symbol(undefined) + +var r1d1 = true * undefined; +>r1d1 : Symbol(r1d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 20, 3)) +>undefined : Symbol(undefined) + +var r1d2 = '' * undefined; +>r1d2 : Symbol(r1d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 21, 3)) +>undefined : Symbol(undefined) + +var r1d3 = {} * undefined; +>r1d3 : Symbol(r1d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 22, 3)) +>undefined : Symbol(undefined) + +// operator / +var r2a1 = undefined / a; +>r2a1 : Symbol(r2a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 25, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r2a2 = undefined / b; +>r2a2 : Symbol(r2a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 26, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r2a3 = undefined / c; +>r2a3 : Symbol(r2a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 27, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r2b1 = a / undefined; +>r2b1 : Symbol(r2b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 29, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r2b2 = b / undefined; +>r2b2 : Symbol(r2b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 30, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r2b3 = c / undefined; +>r2b3 : Symbol(r2b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 31, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r2c1 = undefined / true; +>r2c1 : Symbol(r2c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 33, 3)) +>undefined : Symbol(undefined) + +var r2c2 = undefined / ''; +>r2c2 : Symbol(r2c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 34, 3)) +>undefined : Symbol(undefined) + +var r2c3 = undefined / {}; +>r2c3 : Symbol(r2c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 35, 3)) +>undefined : Symbol(undefined) + +var r2d1 = true / undefined; +>r2d1 : Symbol(r2d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 37, 3)) +>undefined : Symbol(undefined) + +var r2d2 = '' / undefined; +>r2d2 : Symbol(r2d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 38, 3)) +>undefined : Symbol(undefined) + +var r2d3 = {} / undefined; +>r2d3 : Symbol(r2d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 39, 3)) +>undefined : Symbol(undefined) + +// operator % +var r3a1 = undefined % a; +>r3a1 : Symbol(r3a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 42, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r3a2 = undefined % b; +>r3a2 : Symbol(r3a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 43, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r3a3 = undefined % c; +>r3a3 : Symbol(r3a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 44, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r3b1 = a % undefined; +>r3b1 : Symbol(r3b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 46, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r3b2 = b % undefined; +>r3b2 : Symbol(r3b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 47, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r3b3 = c % undefined; +>r3b3 : Symbol(r3b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 48, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r3c1 = undefined % true; +>r3c1 : Symbol(r3c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 50, 3)) +>undefined : Symbol(undefined) + +var r3c2 = undefined % ''; +>r3c2 : Symbol(r3c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 51, 3)) +>undefined : Symbol(undefined) + +var r3c3 = undefined % {}; +>r3c3 : Symbol(r3c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 52, 3)) +>undefined : Symbol(undefined) + +var r3d1 = true % undefined; +>r3d1 : Symbol(r3d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 54, 3)) +>undefined : Symbol(undefined) + +var r3d2 = '' % undefined; +>r3d2 : Symbol(r3d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 55, 3)) +>undefined : Symbol(undefined) + +var r3d3 = {} % undefined; +>r3d3 : Symbol(r3d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 56, 3)) +>undefined : Symbol(undefined) + +// operator - +var r4a1 = undefined - a; +>r4a1 : Symbol(r4a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 59, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r4a2 = undefined - b; +>r4a2 : Symbol(r4a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 60, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r4a3 = undefined - c; +>r4a3 : Symbol(r4a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 61, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r4b1 = a - undefined; +>r4b1 : Symbol(r4b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 63, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r4b2 = b - undefined; +>r4b2 : Symbol(r4b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 64, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r4b3 = c - undefined; +>r4b3 : Symbol(r4b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 65, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r4c1 = undefined - true; +>r4c1 : Symbol(r4c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 67, 3)) +>undefined : Symbol(undefined) + +var r4c2 = undefined - ''; +>r4c2 : Symbol(r4c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 68, 3)) +>undefined : Symbol(undefined) + +var r4c3 = undefined - {}; +>r4c3 : Symbol(r4c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 69, 3)) +>undefined : Symbol(undefined) + +var r4d1 = true - undefined; +>r4d1 : Symbol(r4d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 71, 3)) +>undefined : Symbol(undefined) + +var r4d2 = '' - undefined; +>r4d2 : Symbol(r4d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 72, 3)) +>undefined : Symbol(undefined) + +var r4d3 = {} - undefined; +>r4d3 : Symbol(r4d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 73, 3)) +>undefined : Symbol(undefined) + +// operator << +var r5a1 = undefined << a; +>r5a1 : Symbol(r5a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 76, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r5a2 = undefined << b; +>r5a2 : Symbol(r5a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 77, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r5a3 = undefined << c; +>r5a3 : Symbol(r5a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 78, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r5b1 = a << undefined; +>r5b1 : Symbol(r5b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 80, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r5b2 = b << undefined; +>r5b2 : Symbol(r5b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 81, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r5b3 = c << undefined; +>r5b3 : Symbol(r5b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 82, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r5c1 = undefined << true; +>r5c1 : Symbol(r5c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 84, 3)) +>undefined : Symbol(undefined) + +var r5c2 = undefined << ''; +>r5c2 : Symbol(r5c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 85, 3)) +>undefined : Symbol(undefined) + +var r5c3 = undefined << {}; +>r5c3 : Symbol(r5c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 86, 3)) +>undefined : Symbol(undefined) + +var r5d1 = true << undefined; +>r5d1 : Symbol(r5d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 88, 3)) +>undefined : Symbol(undefined) + +var r5d2 = '' << undefined; +>r5d2 : Symbol(r5d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 89, 3)) +>undefined : Symbol(undefined) + +var r5d3 = {} << undefined; +>r5d3 : Symbol(r5d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 90, 3)) +>undefined : Symbol(undefined) + +// operator >> +var r6a1 = undefined >> a; +>r6a1 : Symbol(r6a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 93, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r6a2 = undefined >> b; +>r6a2 : Symbol(r6a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 94, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r6a3 = undefined >> c; +>r6a3 : Symbol(r6a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 95, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r6b1 = a >> undefined; +>r6b1 : Symbol(r6b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 97, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r6b2 = b >> undefined; +>r6b2 : Symbol(r6b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 98, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r6b3 = c >> undefined; +>r6b3 : Symbol(r6b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 99, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r6c1 = undefined >> true; +>r6c1 : Symbol(r6c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 101, 3)) +>undefined : Symbol(undefined) + +var r6c2 = undefined >> ''; +>r6c2 : Symbol(r6c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 102, 3)) +>undefined : Symbol(undefined) + +var r6c3 = undefined >> {}; +>r6c3 : Symbol(r6c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 103, 3)) +>undefined : Symbol(undefined) + +var r6d1 = true >> undefined; +>r6d1 : Symbol(r6d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 105, 3)) +>undefined : Symbol(undefined) + +var r6d2 = '' >> undefined; +>r6d2 : Symbol(r6d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 106, 3)) +>undefined : Symbol(undefined) + +var r6d3 = {} >> undefined; +>r6d3 : Symbol(r6d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 107, 3)) +>undefined : Symbol(undefined) + +// operator >>> +var r7a1 = undefined >>> a; +>r7a1 : Symbol(r7a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 110, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r7a2 = undefined >>> b; +>r7a2 : Symbol(r7a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 111, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r7a3 = undefined >>> c; +>r7a3 : Symbol(r7a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 112, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r7b1 = a >>> undefined; +>r7b1 : Symbol(r7b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 114, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r7b2 = b >>> undefined; +>r7b2 : Symbol(r7b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 115, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r7b3 = c >>> undefined; +>r7b3 : Symbol(r7b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 116, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r7c1 = undefined >>> true; +>r7c1 : Symbol(r7c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 118, 3)) +>undefined : Symbol(undefined) + +var r7c2 = undefined >>> ''; +>r7c2 : Symbol(r7c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 119, 3)) +>undefined : Symbol(undefined) + +var r7c3 = undefined >>> {}; +>r7c3 : Symbol(r7c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 120, 3)) +>undefined : Symbol(undefined) + +var r7d1 = true >>> undefined; +>r7d1 : Symbol(r7d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 122, 3)) +>undefined : Symbol(undefined) + +var r7d2 = '' >>> undefined; +>r7d2 : Symbol(r7d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 123, 3)) +>undefined : Symbol(undefined) + +var r7d3 = {} >>> undefined; +>r7d3 : Symbol(r7d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 124, 3)) +>undefined : Symbol(undefined) + +// operator & +var r8a1 = undefined & a; +>r8a1 : Symbol(r8a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 127, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r8a2 = undefined & b; +>r8a2 : Symbol(r8a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 128, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r8a3 = undefined & c; +>r8a3 : Symbol(r8a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 129, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r8b1 = a & undefined; +>r8b1 : Symbol(r8b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 131, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r8b2 = b & undefined; +>r8b2 : Symbol(r8b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 132, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r8b3 = c & undefined; +>r8b3 : Symbol(r8b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 133, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r8c1 = undefined & true; +>r8c1 : Symbol(r8c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 135, 3)) +>undefined : Symbol(undefined) + +var r8c2 = undefined & ''; +>r8c2 : Symbol(r8c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 136, 3)) +>undefined : Symbol(undefined) + +var r8c3 = undefined & {}; +>r8c3 : Symbol(r8c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 137, 3)) +>undefined : Symbol(undefined) + +var r8d1 = true & undefined; +>r8d1 : Symbol(r8d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 139, 3)) +>undefined : Symbol(undefined) + +var r8d2 = '' & undefined; +>r8d2 : Symbol(r8d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 140, 3)) +>undefined : Symbol(undefined) + +var r8d3 = {} & undefined; +>r8d3 : Symbol(r8d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 141, 3)) +>undefined : Symbol(undefined) + +// operator ^ +var r9a1 = undefined ^ a; +>r9a1 : Symbol(r9a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 144, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r9a2 = undefined ^ b; +>r9a2 : Symbol(r9a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 145, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r9a3 = undefined ^ c; +>r9a3 : Symbol(r9a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 146, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r9b1 = a ^ undefined; +>r9b1 : Symbol(r9b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 148, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r9b2 = b ^ undefined; +>r9b2 : Symbol(r9b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 149, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r9b3 = c ^ undefined; +>r9b3 : Symbol(r9b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 150, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r9c1 = undefined ^ true; +>r9c1 : Symbol(r9c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 152, 3)) +>undefined : Symbol(undefined) + +var r9c2 = undefined ^ ''; +>r9c2 : Symbol(r9c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 153, 3)) +>undefined : Symbol(undefined) + +var r9c3 = undefined ^ {}; +>r9c3 : Symbol(r9c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 154, 3)) +>undefined : Symbol(undefined) + +var r9d1 = true ^ undefined; +>r9d1 : Symbol(r9d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 156, 3)) +>undefined : Symbol(undefined) + +var r9d2 = '' ^ undefined; +>r9d2 : Symbol(r9d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 157, 3)) +>undefined : Symbol(undefined) + +var r9d3 = {} ^ undefined; +>r9d3 : Symbol(r9d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 158, 3)) +>undefined : Symbol(undefined) + +// operator | +var r10a1 = undefined | a; +>r10a1 : Symbol(r10a1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 161, 3)) +>undefined : Symbol(undefined) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) + +var r10a2 = undefined | b; +>r10a2 : Symbol(r10a2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 162, 3)) +>undefined : Symbol(undefined) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) + +var r10a3 = undefined | c; +>r10a3 : Symbol(r10a3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 163, 3)) +>undefined : Symbol(undefined) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) + +var r10b1 = a | undefined; +>r10b1 : Symbol(r10b1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 165, 3)) +>a : Symbol(a, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 3, 3)) +>undefined : Symbol(undefined) + +var r10b2 = b | undefined; +>r10b2 : Symbol(r10b2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 166, 3)) +>b : Symbol(b, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 4, 3)) +>undefined : Symbol(undefined) + +var r10b3 = c | undefined; +>r10b3 : Symbol(r10b3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 167, 3)) +>c : Symbol(c, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 5, 3)) +>undefined : Symbol(undefined) + +var r10c1 = undefined | true; +>r10c1 : Symbol(r10c1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 169, 3)) +>undefined : Symbol(undefined) + +var r10c2 = undefined | ''; +>r10c2 : Symbol(r10c2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 170, 3)) +>undefined : Symbol(undefined) + +var r10c3 = undefined | {}; +>r10c3 : Symbol(r10c3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 171, 3)) +>undefined : Symbol(undefined) + +var r10d1 = true | undefined; +>r10d1 : Symbol(r10d1, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 173, 3)) +>undefined : Symbol(undefined) + +var r10d2 = '' | undefined; +>r10d2 : Symbol(r10d2, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 174, 3)) +>undefined : Symbol(undefined) + +var r10d3 = {} | undefined; +>r10d3 : Symbol(r10d3, Decl(arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts, 175, 3)) +>undefined : Symbol(undefined) + diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types new file mode 100644 index 00000000000..3211250146b --- /dev/null +++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndInvalidOperands.types @@ -0,0 +1,744 @@ +=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndInvalidOperands.ts === +// If one operand is the undefined or undefined value, it is treated as having the type of the +// other operand. + +var a: boolean; +>a : boolean + +var b: string; +>b : string + +var c: Object; +>c : Object +>Object : Object + +// operator * +var r1a1 = undefined * a; +>r1a1 : number +>undefined * a : number +>undefined : undefined +>a : boolean + +var r1a2 = undefined * b; +>r1a2 : number +>undefined * b : number +>undefined : undefined +>b : string + +var r1a3 = undefined * c; +>r1a3 : number +>undefined * c : number +>undefined : undefined +>c : Object + +var r1b1 = a * undefined; +>r1b1 : number +>a * undefined : number +>a : boolean +>undefined : undefined + +var r1b2 = b * undefined; +>r1b2 : number +>b * undefined : number +>b : string +>undefined : undefined + +var r1b3 = c * undefined; +>r1b3 : number +>c * undefined : number +>c : Object +>undefined : undefined + +var r1c1 = undefined * true; +>r1c1 : number +>undefined * true : number +>undefined : undefined +>true : true + +var r1c2 = undefined * ''; +>r1c2 : number +>undefined * '' : number +>undefined : undefined +>'' : "" + +var r1c3 = undefined * {}; +>r1c3 : number +>undefined * {} : number +>undefined : undefined +>{} : {} + +var r1d1 = true * undefined; +>r1d1 : number +>true * undefined : number +>true : true +>undefined : undefined + +var r1d2 = '' * undefined; +>r1d2 : number +>'' * undefined : number +>'' : "" +>undefined : undefined + +var r1d3 = {} * undefined; +>r1d3 : number +>{} * undefined : number +>{} : {} +>undefined : undefined + +// operator / +var r2a1 = undefined / a; +>r2a1 : number +>undefined / a : number +>undefined : undefined +>a : boolean + +var r2a2 = undefined / b; +>r2a2 : number +>undefined / b : number +>undefined : undefined +>b : string + +var r2a3 = undefined / c; +>r2a3 : number +>undefined / c : number +>undefined : undefined +>c : Object + +var r2b1 = a / undefined; +>r2b1 : number +>a / undefined : number +>a : boolean +>undefined : undefined + +var r2b2 = b / undefined; +>r2b2 : number +>b / undefined : number +>b : string +>undefined : undefined + +var r2b3 = c / undefined; +>r2b3 : number +>c / undefined : number +>c : Object +>undefined : undefined + +var r2c1 = undefined / true; +>r2c1 : number +>undefined / true : number +>undefined : undefined +>true : true + +var r2c2 = undefined / ''; +>r2c2 : number +>undefined / '' : number +>undefined : undefined +>'' : "" + +var r2c3 = undefined / {}; +>r2c3 : number +>undefined / {} : number +>undefined : undefined +>{} : {} + +var r2d1 = true / undefined; +>r2d1 : number +>true / undefined : number +>true : true +>undefined : undefined + +var r2d2 = '' / undefined; +>r2d2 : number +>'' / undefined : number +>'' : "" +>undefined : undefined + +var r2d3 = {} / undefined; +>r2d3 : number +>{} / undefined : number +>{} : {} +>undefined : undefined + +// operator % +var r3a1 = undefined % a; +>r3a1 : number +>undefined % a : number +>undefined : undefined +>a : boolean + +var r3a2 = undefined % b; +>r3a2 : number +>undefined % b : number +>undefined : undefined +>b : string + +var r3a3 = undefined % c; +>r3a3 : number +>undefined % c : number +>undefined : undefined +>c : Object + +var r3b1 = a % undefined; +>r3b1 : number +>a % undefined : number +>a : boolean +>undefined : undefined + +var r3b2 = b % undefined; +>r3b2 : number +>b % undefined : number +>b : string +>undefined : undefined + +var r3b3 = c % undefined; +>r3b3 : number +>c % undefined : number +>c : Object +>undefined : undefined + +var r3c1 = undefined % true; +>r3c1 : number +>undefined % true : number +>undefined : undefined +>true : true + +var r3c2 = undefined % ''; +>r3c2 : number +>undefined % '' : number +>undefined : undefined +>'' : "" + +var r3c3 = undefined % {}; +>r3c3 : number +>undefined % {} : number +>undefined : undefined +>{} : {} + +var r3d1 = true % undefined; +>r3d1 : number +>true % undefined : number +>true : true +>undefined : undefined + +var r3d2 = '' % undefined; +>r3d2 : number +>'' % undefined : number +>'' : "" +>undefined : undefined + +var r3d3 = {} % undefined; +>r3d3 : number +>{} % undefined : number +>{} : {} +>undefined : undefined + +// operator - +var r4a1 = undefined - a; +>r4a1 : number +>undefined - a : number +>undefined : undefined +>a : boolean + +var r4a2 = undefined - b; +>r4a2 : number +>undefined - b : number +>undefined : undefined +>b : string + +var r4a3 = undefined - c; +>r4a3 : number +>undefined - c : number +>undefined : undefined +>c : Object + +var r4b1 = a - undefined; +>r4b1 : number +>a - undefined : number +>a : boolean +>undefined : undefined + +var r4b2 = b - undefined; +>r4b2 : number +>b - undefined : number +>b : string +>undefined : undefined + +var r4b3 = c - undefined; +>r4b3 : number +>c - undefined : number +>c : Object +>undefined : undefined + +var r4c1 = undefined - true; +>r4c1 : number +>undefined - true : number +>undefined : undefined +>true : true + +var r4c2 = undefined - ''; +>r4c2 : number +>undefined - '' : number +>undefined : undefined +>'' : "" + +var r4c3 = undefined - {}; +>r4c3 : number +>undefined - {} : number +>undefined : undefined +>{} : {} + +var r4d1 = true - undefined; +>r4d1 : number +>true - undefined : number +>true : true +>undefined : undefined + +var r4d2 = '' - undefined; +>r4d2 : number +>'' - undefined : number +>'' : "" +>undefined : undefined + +var r4d3 = {} - undefined; +>r4d3 : number +>{} - undefined : number +>{} : {} +>undefined : undefined + +// operator << +var r5a1 = undefined << a; +>r5a1 : number +>undefined << a : number +>undefined : undefined +>a : boolean + +var r5a2 = undefined << b; +>r5a2 : number +>undefined << b : number +>undefined : undefined +>b : string + +var r5a3 = undefined << c; +>r5a3 : number +>undefined << c : number +>undefined : undefined +>c : Object + +var r5b1 = a << undefined; +>r5b1 : number +>a << undefined : number +>a : boolean +>undefined : undefined + +var r5b2 = b << undefined; +>r5b2 : number +>b << undefined : number +>b : string +>undefined : undefined + +var r5b3 = c << undefined; +>r5b3 : number +>c << undefined : number +>c : Object +>undefined : undefined + +var r5c1 = undefined << true; +>r5c1 : number +>undefined << true : number +>undefined : undefined +>true : true + +var r5c2 = undefined << ''; +>r5c2 : number +>undefined << '' : number +>undefined : undefined +>'' : "" + +var r5c3 = undefined << {}; +>r5c3 : number +>undefined << {} : number +>undefined : undefined +>{} : {} + +var r5d1 = true << undefined; +>r5d1 : number +>true << undefined : number +>true : true +>undefined : undefined + +var r5d2 = '' << undefined; +>r5d2 : number +>'' << undefined : number +>'' : "" +>undefined : undefined + +var r5d3 = {} << undefined; +>r5d3 : number +>{} << undefined : number +>{} : {} +>undefined : undefined + +// operator >> +var r6a1 = undefined >> a; +>r6a1 : number +>undefined >> a : number +>undefined : undefined +>a : boolean + +var r6a2 = undefined >> b; +>r6a2 : number +>undefined >> b : number +>undefined : undefined +>b : string + +var r6a3 = undefined >> c; +>r6a3 : number +>undefined >> c : number +>undefined : undefined +>c : Object + +var r6b1 = a >> undefined; +>r6b1 : number +>a >> undefined : number +>a : boolean +>undefined : undefined + +var r6b2 = b >> undefined; +>r6b2 : number +>b >> undefined : number +>b : string +>undefined : undefined + +var r6b3 = c >> undefined; +>r6b3 : number +>c >> undefined : number +>c : Object +>undefined : undefined + +var r6c1 = undefined >> true; +>r6c1 : number +>undefined >> true : number +>undefined : undefined +>true : true + +var r6c2 = undefined >> ''; +>r6c2 : number +>undefined >> '' : number +>undefined : undefined +>'' : "" + +var r6c3 = undefined >> {}; +>r6c3 : number +>undefined >> {} : number +>undefined : undefined +>{} : {} + +var r6d1 = true >> undefined; +>r6d1 : number +>true >> undefined : number +>true : true +>undefined : undefined + +var r6d2 = '' >> undefined; +>r6d2 : number +>'' >> undefined : number +>'' : "" +>undefined : undefined + +var r6d3 = {} >> undefined; +>r6d3 : number +>{} >> undefined : number +>{} : {} +>undefined : undefined + +// operator >>> +var r7a1 = undefined >>> a; +>r7a1 : number +>undefined >>> a : number +>undefined : undefined +>a : boolean + +var r7a2 = undefined >>> b; +>r7a2 : number +>undefined >>> b : number +>undefined : undefined +>b : string + +var r7a3 = undefined >>> c; +>r7a3 : number +>undefined >>> c : number +>undefined : undefined +>c : Object + +var r7b1 = a >>> undefined; +>r7b1 : number +>a >>> undefined : number +>a : boolean +>undefined : undefined + +var r7b2 = b >>> undefined; +>r7b2 : number +>b >>> undefined : number +>b : string +>undefined : undefined + +var r7b3 = c >>> undefined; +>r7b3 : number +>c >>> undefined : number +>c : Object +>undefined : undefined + +var r7c1 = undefined >>> true; +>r7c1 : number +>undefined >>> true : number +>undefined : undefined +>true : true + +var r7c2 = undefined >>> ''; +>r7c2 : number +>undefined >>> '' : number +>undefined : undefined +>'' : "" + +var r7c3 = undefined >>> {}; +>r7c3 : number +>undefined >>> {} : number +>undefined : undefined +>{} : {} + +var r7d1 = true >>> undefined; +>r7d1 : number +>true >>> undefined : number +>true : true +>undefined : undefined + +var r7d2 = '' >>> undefined; +>r7d2 : number +>'' >>> undefined : number +>'' : "" +>undefined : undefined + +var r7d3 = {} >>> undefined; +>r7d3 : number +>{} >>> undefined : number +>{} : {} +>undefined : undefined + +// operator & +var r8a1 = undefined & a; +>r8a1 : number +>undefined & a : number +>undefined : undefined +>a : boolean + +var r8a2 = undefined & b; +>r8a2 : number +>undefined & b : number +>undefined : undefined +>b : string + +var r8a3 = undefined & c; +>r8a3 : number +>undefined & c : number +>undefined : undefined +>c : Object + +var r8b1 = a & undefined; +>r8b1 : number +>a & undefined : number +>a : boolean +>undefined : undefined + +var r8b2 = b & undefined; +>r8b2 : number +>b & undefined : number +>b : string +>undefined : undefined + +var r8b3 = c & undefined; +>r8b3 : number +>c & undefined : number +>c : Object +>undefined : undefined + +var r8c1 = undefined & true; +>r8c1 : number +>undefined & true : number +>undefined : undefined +>true : true + +var r8c2 = undefined & ''; +>r8c2 : number +>undefined & '' : number +>undefined : undefined +>'' : "" + +var r8c3 = undefined & {}; +>r8c3 : number +>undefined & {} : number +>undefined : undefined +>{} : {} + +var r8d1 = true & undefined; +>r8d1 : number +>true & undefined : number +>true : true +>undefined : undefined + +var r8d2 = '' & undefined; +>r8d2 : number +>'' & undefined : number +>'' : "" +>undefined : undefined + +var r8d3 = {} & undefined; +>r8d3 : number +>{} & undefined : number +>{} : {} +>undefined : undefined + +// operator ^ +var r9a1 = undefined ^ a; +>r9a1 : number +>undefined ^ a : number +>undefined : undefined +>a : boolean + +var r9a2 = undefined ^ b; +>r9a2 : number +>undefined ^ b : number +>undefined : undefined +>b : string + +var r9a3 = undefined ^ c; +>r9a3 : number +>undefined ^ c : number +>undefined : undefined +>c : Object + +var r9b1 = a ^ undefined; +>r9b1 : number +>a ^ undefined : number +>a : boolean +>undefined : undefined + +var r9b2 = b ^ undefined; +>r9b2 : number +>b ^ undefined : number +>b : string +>undefined : undefined + +var r9b3 = c ^ undefined; +>r9b3 : number +>c ^ undefined : number +>c : Object +>undefined : undefined + +var r9c1 = undefined ^ true; +>r9c1 : number +>undefined ^ true : number +>undefined : undefined +>true : true + +var r9c2 = undefined ^ ''; +>r9c2 : number +>undefined ^ '' : number +>undefined : undefined +>'' : "" + +var r9c3 = undefined ^ {}; +>r9c3 : number +>undefined ^ {} : number +>undefined : undefined +>{} : {} + +var r9d1 = true ^ undefined; +>r9d1 : number +>true ^ undefined : number +>true : true +>undefined : undefined + +var r9d2 = '' ^ undefined; +>r9d2 : number +>'' ^ undefined : number +>'' : "" +>undefined : undefined + +var r9d3 = {} ^ undefined; +>r9d3 : number +>{} ^ undefined : number +>{} : {} +>undefined : undefined + +// operator | +var r10a1 = undefined | a; +>r10a1 : number +>undefined | a : number +>undefined : undefined +>a : boolean + +var r10a2 = undefined | b; +>r10a2 : number +>undefined | b : number +>undefined : undefined +>b : string + +var r10a3 = undefined | c; +>r10a3 : number +>undefined | c : number +>undefined : undefined +>c : Object + +var r10b1 = a | undefined; +>r10b1 : number +>a | undefined : number +>a : boolean +>undefined : undefined + +var r10b2 = b | undefined; +>r10b2 : number +>b | undefined : number +>b : string +>undefined : undefined + +var r10b3 = c | undefined; +>r10b3 : number +>c | undefined : number +>c : Object +>undefined : undefined + +var r10c1 = undefined | true; +>r10c1 : number +>undefined | true : number +>undefined : undefined +>true : true + +var r10c2 = undefined | ''; +>r10c2 : number +>undefined | '' : number +>undefined : undefined +>'' : "" + +var r10c3 = undefined | {}; +>r10c3 : number +>undefined | {} : number +>undefined : undefined +>{} : {} + +var r10d1 = true | undefined; +>r10d1 : number +>true | undefined : number +>true : true +>undefined : undefined + +var r10d2 = '' | undefined; +>r10d2 : number +>'' | undefined : number +>'' : "" +>undefined : undefined + +var r10d3 = {} | undefined; +>r10d3 : number +>{} | undefined : number +>{} : {} +>undefined : undefined + diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.symbols b/tests/baselines/reference/arityAndOrderCompatibility01.symbols new file mode 100644 index 00000000000..c6ef08a845b --- /dev/null +++ b/tests/baselines/reference/arityAndOrderCompatibility01.symbols @@ -0,0 +1,113 @@ +=== tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts === +interface StrNum extends Array { +>StrNum : Symbol(StrNum, Decl(arityAndOrderCompatibility01.ts, 0, 0)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + 0: string; + 1: number; +} + +var x: [string, number]; +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var y: StrNum +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) +>StrNum : Symbol(StrNum, Decl(arityAndOrderCompatibility01.ts, 0, 0)) + +var z: { +>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 7, 3)) + + 0: string; + 1: number; +} + +var [a, b, c] = x; +>a : Symbol(a, Decl(arityAndOrderCompatibility01.ts, 12, 5)) +>b : Symbol(b, Decl(arityAndOrderCompatibility01.ts, 12, 7)) +>c : Symbol(c, Decl(arityAndOrderCompatibility01.ts, 12, 10)) +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var [d, e, f] = y; +>d : Symbol(d, Decl(arityAndOrderCompatibility01.ts, 13, 5)) +>e : Symbol(e, Decl(arityAndOrderCompatibility01.ts, 13, 7)) +>f : Symbol(f, Decl(arityAndOrderCompatibility01.ts, 13, 10)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + +var [g, h, i] = z; +>g : Symbol(g, Decl(arityAndOrderCompatibility01.ts, 14, 5)) +>h : Symbol(h, Decl(arityAndOrderCompatibility01.ts, 14, 7)) +>i : Symbol(i, Decl(arityAndOrderCompatibility01.ts, 14, 10)) +>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 7, 3)) + +var j1: [number, number, number] = x; +>j1 : Symbol(j1, Decl(arityAndOrderCompatibility01.ts, 15, 3)) +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var j2: [number, number, number] = y; +>j2 : Symbol(j2, Decl(arityAndOrderCompatibility01.ts, 16, 3)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + +var j3: [number, number, number] = z; +>j3 : Symbol(j3, Decl(arityAndOrderCompatibility01.ts, 17, 3)) +>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 7, 3)) + +var k1: [string, number, number] = x; +>k1 : Symbol(k1, Decl(arityAndOrderCompatibility01.ts, 18, 3)) +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var k2: [string, number, number] = y; +>k2 : Symbol(k2, Decl(arityAndOrderCompatibility01.ts, 19, 3)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + +var k3: [string, number, number] = z; +>k3 : Symbol(k3, Decl(arityAndOrderCompatibility01.ts, 20, 3)) +>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 7, 3)) + +var l1: [number] = x; +>l1 : Symbol(l1, Decl(arityAndOrderCompatibility01.ts, 21, 3)) +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var l2: [number] = y; +>l2 : Symbol(l2, Decl(arityAndOrderCompatibility01.ts, 22, 3)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + +var l3: [number] = z; +>l3 : Symbol(l3, Decl(arityAndOrderCompatibility01.ts, 23, 3)) +>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 7, 3)) + +var m1: [string] = x; +>m1 : Symbol(m1, Decl(arityAndOrderCompatibility01.ts, 24, 3)) +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var m2: [string] = y; +>m2 : Symbol(m2, Decl(arityAndOrderCompatibility01.ts, 25, 3)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + +var m3: [string] = z; +>m3 : Symbol(m3, Decl(arityAndOrderCompatibility01.ts, 26, 3)) +>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 7, 3)) + +var n1: [number, string] = x; +>n1 : Symbol(n1, Decl(arityAndOrderCompatibility01.ts, 27, 3)) +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var n2: [number, string] = y; +>n2 : Symbol(n2, Decl(arityAndOrderCompatibility01.ts, 28, 3)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + +var n3: [number, string] = z; +>n3 : Symbol(n3, Decl(arityAndOrderCompatibility01.ts, 29, 3)) +>z : Symbol(z, Decl(arityAndOrderCompatibility01.ts, 7, 3)) + +var o1: [string, number] = x; +>o1 : Symbol(o1, Decl(arityAndOrderCompatibility01.ts, 30, 3)) +>x : Symbol(x, Decl(arityAndOrderCompatibility01.ts, 5, 3)) + +var o2: [string, number] = y; +>o2 : Symbol(o2, Decl(arityAndOrderCompatibility01.ts, 31, 3)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + +var o3: [string, number] = y; +>o3 : Symbol(o3, Decl(arityAndOrderCompatibility01.ts, 32, 3)) +>y : Symbol(y, Decl(arityAndOrderCompatibility01.ts, 6, 3)) + diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.types b/tests/baselines/reference/arityAndOrderCompatibility01.types new file mode 100644 index 00000000000..934c5c6966d --- /dev/null +++ b/tests/baselines/reference/arityAndOrderCompatibility01.types @@ -0,0 +1,113 @@ +=== tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts === +interface StrNum extends Array { +>StrNum : StrNum +>Array : T[] + + 0: string; + 1: number; +} + +var x: [string, number]; +>x : [string, number] + +var y: StrNum +>y : StrNum +>StrNum : StrNum + +var z: { +>z : { 0: string; 1: number; } + + 0: string; + 1: number; +} + +var [a, b, c] = x; +>a : string +>b : number +>c : any +>x : [string, number] + +var [d, e, f] = y; +>d : string +>e : number +>f : any +>y : StrNum + +var [g, h, i] = z; +>g : string +>h : number +>i : any +>z : { 0: string; 1: number; } + +var j1: [number, number, number] = x; +>j1 : [number, number, number] +>x : [string, number] + +var j2: [number, number, number] = y; +>j2 : [number, number, number] +>y : StrNum + +var j3: [number, number, number] = z; +>j3 : [number, number, number] +>z : { 0: string; 1: number; } + +var k1: [string, number, number] = x; +>k1 : [string, number, number] +>x : [string, number] + +var k2: [string, number, number] = y; +>k2 : [string, number, number] +>y : StrNum + +var k3: [string, number, number] = z; +>k3 : [string, number, number] +>z : { 0: string; 1: number; } + +var l1: [number] = x; +>l1 : [number] +>x : [string, number] + +var l2: [number] = y; +>l2 : [number] +>y : StrNum + +var l3: [number] = z; +>l3 : [number] +>z : { 0: string; 1: number; } + +var m1: [string] = x; +>m1 : [string] +>x : [string, number] + +var m2: [string] = y; +>m2 : [string] +>y : StrNum + +var m3: [string] = z; +>m3 : [string] +>z : { 0: string; 1: number; } + +var n1: [number, string] = x; +>n1 : [number, string] +>x : [string, number] + +var n2: [number, string] = y; +>n2 : [number, string] +>y : StrNum + +var n3: [number, string] = z; +>n3 : [number, string] +>z : { 0: string; 1: number; } + +var o1: [string, number] = x; +>o1 : [string, number] +>x : [string, number] + +var o2: [string, number] = y; +>o2 : [string, number] +>y : StrNum + +var o3: [string, number] = y; +>o3 : [string, number] +>y : StrNum + diff --git a/tests/baselines/reference/arrayAssignmentTest1.symbols b/tests/baselines/reference/arrayAssignmentTest1.symbols new file mode 100644 index 00000000000..8f9445fd56c --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest1.symbols @@ -0,0 +1,233 @@ +=== tests/cases/compiler/arrayAssignmentTest1.ts === +interface I1 { +>I1 : Symbol(I1, Decl(arrayAssignmentTest1.ts, 0, 0)) + + IM1():void[]; +>IM1 : Symbol(I1.IM1, Decl(arrayAssignmentTest1.ts, 0, 14)) +} + +class C1 implements I1 { +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest1.ts, 0, 0)) + + IM1():void[] {return null;} +>IM1 : Symbol(C1.IM1, Decl(arrayAssignmentTest1.ts, 4, 24)) + + C1M1():C1[] {return null;} +>C1M1 : Symbol(C1.C1M1, Decl(arrayAssignmentTest1.ts, 5, 28)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) + } +class C2 extends C1 { +>C2 : Symbol(C2, Decl(arrayAssignmentTest1.ts, 7, 2)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) + + C2M1():C2[] { return null;} +>C2M1 : Symbol(C2.C2M1, Decl(arrayAssignmentTest1.ts, 8, 21)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest1.ts, 7, 2)) +} + +class C3 { +>C3 : Symbol(C3, Decl(arrayAssignmentTest1.ts, 10, 1)) + + CM3M1() { return 3;} +>CM3M1 : Symbol(C3.CM3M1, Decl(arrayAssignmentTest1.ts, 12, 10)) +} + + +/* + +This behaves unexpectedly with the following types: + +Type 1 of any[]: + +* Type 2 of the following throws an error but shouldn't: () => void[], SomeClass[], and {one: 1}[]. + +* Type 2 of the following doesn't throw an error but should: {one: 1}, new() => SomeClass, SomeClass. + +*/ +var a1 : any = null; +>a1 : Symbol(a1, Decl(arrayAssignmentTest1.ts, 28, 3)) + +var c1 : C1 = new C1(); +>c1 : Symbol(c1, Decl(arrayAssignmentTest1.ts, 29, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) + +var i1 : I1 = c1; +>i1 : Symbol(i1, Decl(arrayAssignmentTest1.ts, 30, 3)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest1.ts, 0, 0)) +>c1 : Symbol(c1, Decl(arrayAssignmentTest1.ts, 29, 3)) + +var c2 : C2 = new C2(); +>c2 : Symbol(c2, Decl(arrayAssignmentTest1.ts, 31, 3)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest1.ts, 7, 2)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest1.ts, 7, 2)) + +var c3 : C3 = new C3(); +>c3 : Symbol(c3, Decl(arrayAssignmentTest1.ts, 32, 3)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest1.ts, 10, 1)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest1.ts, 10, 1)) + +var o1 = {one : 1}; +>o1 : Symbol(o1, Decl(arrayAssignmentTest1.ts, 33, 3)) +>one : Symbol(one, Decl(arrayAssignmentTest1.ts, 33, 10)) + +var f1 = function () { return new C1();} +>f1 : Symbol(f1, Decl(arrayAssignmentTest1.ts, 34, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) + +var arr_any: any[] = []; +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) + +var arr_i1: I1[] = []; +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest1.ts, 0, 0)) + +var arr_c1: C1[] = []; +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) + +var arr_c2: C2[] = []; +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest1.ts, 7, 2)) + +var arr_i1_2: I1[] = []; +>arr_i1_2 : Symbol(arr_i1_2, Decl(arrayAssignmentTest1.ts, 40, 3)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest1.ts, 0, 0)) + +var arr_c1_2: C1[] = []; +>arr_c1_2 : Symbol(arr_c1_2, Decl(arrayAssignmentTest1.ts, 41, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) + +var arr_c2_2: C2[] = []; +>arr_c2_2 : Symbol(arr_c2_2, Decl(arrayAssignmentTest1.ts, 42, 3)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest1.ts, 7, 2)) + +var arr_c3: C3[] = []; +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest1.ts, 10, 1)) + +var i1_error: I1 = []; // should be an error - is +>i1_error : Symbol(i1_error, Decl(arrayAssignmentTest1.ts, 45, 3)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest1.ts, 0, 0)) + +var c1_error: C1 = []; // should be an error - is +>c1_error : Symbol(c1_error, Decl(arrayAssignmentTest1.ts, 46, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest1.ts, 2, 1)) + +var c2_error: C2 = []; // should be an error - is +>c2_error : Symbol(c2_error, Decl(arrayAssignmentTest1.ts, 47, 3)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest1.ts, 7, 2)) + +var c3_error: C3 = []; // should be an error - is +>c3_error : Symbol(c3_error, Decl(arrayAssignmentTest1.ts, 48, 3)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest1.ts, 10, 1)) + + +arr_any = arr_i1; // should be ok - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) + +arr_any = arr_c1; // should be ok - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) + +arr_any = arr_c2; // should be ok - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) + +arr_any = arr_c3; // should be ok - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) + +arr_i1 = arr_i1; // should be ok - subtype relationship - is +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) + +arr_i1 = arr_c1; // should be ok - subtype relationship - is +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) + +arr_i1 = arr_c2; // should be ok - subtype relationship - is +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) + +arr_i1 = arr_c3; // should be an error - is +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) + +arr_c1 = arr_c1; // should be ok - subtype relationship - is +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) + +arr_c1 = arr_c2; // should be ok - subtype relationship - is +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) + +arr_c1 = arr_i1; // should be an error - is +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) + +arr_c1 = arr_c3; // should be an error - is +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) + +arr_c2 = arr_c2; // should be ok - subtype relationship - is +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) + +arr_c2 = arr_c1; // should be an error - subtype relationship - is +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest1.ts, 38, 3)) + +arr_c2 = arr_i1; // should be an error - subtype relationship - is +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest1.ts, 37, 3)) + +arr_c2 = arr_c3; // should be an error - is +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest1.ts, 39, 3)) +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) + +// "clean up bug" occurs at this point +// if you move these three expressions to another file, they raise an error +// something to do with state from the above propagating forward? +arr_c3 = arr_c2_2; // should be an error - is +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) +>arr_c2_2 : Symbol(arr_c2_2, Decl(arrayAssignmentTest1.ts, 42, 3)) + +arr_c3 = arr_c1_2; // should be an error - is +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) +>arr_c1_2 : Symbol(arr_c1_2, Decl(arrayAssignmentTest1.ts, 41, 3)) + +arr_c3 = arr_i1_2; // should be an error - is +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest1.ts, 43, 3)) +>arr_i1_2 : Symbol(arr_i1_2, Decl(arrayAssignmentTest1.ts, 40, 3)) + +arr_any = f1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>f1 : Symbol(f1, Decl(arrayAssignmentTest1.ts, 34, 3)) + +arr_any = o1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>o1 : Symbol(o1, Decl(arrayAssignmentTest1.ts, 33, 3)) + +arr_any = a1; // should be ok - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>a1 : Symbol(a1, Decl(arrayAssignmentTest1.ts, 28, 3)) + +arr_any = c1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>c1 : Symbol(c1, Decl(arrayAssignmentTest1.ts, 29, 3)) + +arr_any = c2; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>c2 : Symbol(c2, Decl(arrayAssignmentTest1.ts, 31, 3)) + +arr_any = c3; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>c3 : Symbol(c3, Decl(arrayAssignmentTest1.ts, 32, 3)) + +arr_any = i1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest1.ts, 36, 3)) +>i1 : Symbol(i1, Decl(arrayAssignmentTest1.ts, 30, 3)) + diff --git a/tests/baselines/reference/arrayAssignmentTest1.types b/tests/baselines/reference/arrayAssignmentTest1.types new file mode 100644 index 00000000000..c46d6971eec --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest1.types @@ -0,0 +1,283 @@ +=== tests/cases/compiler/arrayAssignmentTest1.ts === +interface I1 { +>I1 : I1 + + IM1():void[]; +>IM1 : () => void[] +} + +class C1 implements I1 { +>C1 : C1 +>I1 : I1 + + IM1():void[] {return null;} +>IM1 : () => void[] +>null : null + + C1M1():C1[] {return null;} +>C1M1 : () => C1[] +>C1 : C1 +>null : null + } +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + C2M1():C2[] { return null;} +>C2M1 : () => C2[] +>C2 : C2 +>null : null +} + +class C3 { +>C3 : C3 + + CM3M1() { return 3;} +>CM3M1 : () => number +>3 : 3 +} + + +/* + +This behaves unexpectedly with the following types: + +Type 1 of any[]: + +* Type 2 of the following throws an error but shouldn't: () => void[], SomeClass[], and {one: 1}[]. + +* Type 2 of the following doesn't throw an error but should: {one: 1}, new() => SomeClass, SomeClass. + +*/ +var a1 : any = null; +>a1 : any +>null : null + +var c1 : C1 = new C1(); +>c1 : C1 +>C1 : C1 +>new C1() : C1 +>C1 : typeof C1 + +var i1 : I1 = c1; +>i1 : I1 +>I1 : I1 +>c1 : C1 + +var c2 : C2 = new C2(); +>c2 : C2 +>C2 : C2 +>new C2() : C2 +>C2 : typeof C2 + +var c3 : C3 = new C3(); +>c3 : C3 +>C3 : C3 +>new C3() : C3 +>C3 : typeof C3 + +var o1 = {one : 1}; +>o1 : { one: number; } +>{one : 1} : { one: number; } +>one : number +>1 : 1 + +var f1 = function () { return new C1();} +>f1 : () => C1 +>function () { return new C1();} : () => C1 +>new C1() : C1 +>C1 : typeof C1 + +var arr_any: any[] = []; +>arr_any : any[] +>[] : undefined[] + +var arr_i1: I1[] = []; +>arr_i1 : I1[] +>I1 : I1 +>[] : undefined[] + +var arr_c1: C1[] = []; +>arr_c1 : C1[] +>C1 : C1 +>[] : undefined[] + +var arr_c2: C2[] = []; +>arr_c2 : C2[] +>C2 : C2 +>[] : undefined[] + +var arr_i1_2: I1[] = []; +>arr_i1_2 : I1[] +>I1 : I1 +>[] : undefined[] + +var arr_c1_2: C1[] = []; +>arr_c1_2 : C1[] +>C1 : C1 +>[] : undefined[] + +var arr_c2_2: C2[] = []; +>arr_c2_2 : C2[] +>C2 : C2 +>[] : undefined[] + +var arr_c3: C3[] = []; +>arr_c3 : C3[] +>C3 : C3 +>[] : undefined[] + +var i1_error: I1 = []; // should be an error - is +>i1_error : I1 +>I1 : I1 +>[] : undefined[] + +var c1_error: C1 = []; // should be an error - is +>c1_error : C1 +>C1 : C1 +>[] : undefined[] + +var c2_error: C2 = []; // should be an error - is +>c2_error : C2 +>C2 : C2 +>[] : undefined[] + +var c3_error: C3 = []; // should be an error - is +>c3_error : C3 +>C3 : C3 +>[] : undefined[] + + +arr_any = arr_i1; // should be ok - is +>arr_any = arr_i1 : I1[] +>arr_any : any[] +>arr_i1 : I1[] + +arr_any = arr_c1; // should be ok - is +>arr_any = arr_c1 : C1[] +>arr_any : any[] +>arr_c1 : C1[] + +arr_any = arr_c2; // should be ok - is +>arr_any = arr_c2 : C2[] +>arr_any : any[] +>arr_c2 : C2[] + +arr_any = arr_c3; // should be ok - is +>arr_any = arr_c3 : C3[] +>arr_any : any[] +>arr_c3 : C3[] + +arr_i1 = arr_i1; // should be ok - subtype relationship - is +>arr_i1 = arr_i1 : I1[] +>arr_i1 : I1[] +>arr_i1 : I1[] + +arr_i1 = arr_c1; // should be ok - subtype relationship - is +>arr_i1 = arr_c1 : C1[] +>arr_i1 : I1[] +>arr_c1 : C1[] + +arr_i1 = arr_c2; // should be ok - subtype relationship - is +>arr_i1 = arr_c2 : C2[] +>arr_i1 : I1[] +>arr_c2 : C2[] + +arr_i1 = arr_c3; // should be an error - is +>arr_i1 = arr_c3 : C3[] +>arr_i1 : I1[] +>arr_c3 : C3[] + +arr_c1 = arr_c1; // should be ok - subtype relationship - is +>arr_c1 = arr_c1 : C1[] +>arr_c1 : C1[] +>arr_c1 : C1[] + +arr_c1 = arr_c2; // should be ok - subtype relationship - is +>arr_c1 = arr_c2 : C2[] +>arr_c1 : C1[] +>arr_c2 : C2[] + +arr_c1 = arr_i1; // should be an error - is +>arr_c1 = arr_i1 : I1[] +>arr_c1 : C1[] +>arr_i1 : I1[] + +arr_c1 = arr_c3; // should be an error - is +>arr_c1 = arr_c3 : C3[] +>arr_c1 : C1[] +>arr_c3 : C3[] + +arr_c2 = arr_c2; // should be ok - subtype relationship - is +>arr_c2 = arr_c2 : C2[] +>arr_c2 : C2[] +>arr_c2 : C2[] + +arr_c2 = arr_c1; // should be an error - subtype relationship - is +>arr_c2 = arr_c1 : C1[] +>arr_c2 : C2[] +>arr_c1 : C1[] + +arr_c2 = arr_i1; // should be an error - subtype relationship - is +>arr_c2 = arr_i1 : I1[] +>arr_c2 : C2[] +>arr_i1 : I1[] + +arr_c2 = arr_c3; // should be an error - is +>arr_c2 = arr_c3 : C3[] +>arr_c2 : C2[] +>arr_c3 : C3[] + +// "clean up bug" occurs at this point +// if you move these three expressions to another file, they raise an error +// something to do with state from the above propagating forward? +arr_c3 = arr_c2_2; // should be an error - is +>arr_c3 = arr_c2_2 : C2[] +>arr_c3 : C3[] +>arr_c2_2 : C2[] + +arr_c3 = arr_c1_2; // should be an error - is +>arr_c3 = arr_c1_2 : C1[] +>arr_c3 : C3[] +>arr_c1_2 : C1[] + +arr_c3 = arr_i1_2; // should be an error - is +>arr_c3 = arr_i1_2 : I1[] +>arr_c3 : C3[] +>arr_i1_2 : I1[] + +arr_any = f1; // should be an error - is +>arr_any = f1 : () => C1 +>arr_any : any[] +>f1 : () => C1 + +arr_any = o1; // should be an error - is +>arr_any = o1 : { one: number; } +>arr_any : any[] +>o1 : { one: number; } + +arr_any = a1; // should be ok - is +>arr_any = a1 : any +>arr_any : any[] +>a1 : any + +arr_any = c1; // should be an error - is +>arr_any = c1 : C1 +>arr_any : any[] +>c1 : C1 + +arr_any = c2; // should be an error - is +>arr_any = c2 : C2 +>arr_any : any[] +>c2 : C2 + +arr_any = c3; // should be an error - is +>arr_any = c3 : C3 +>arr_any : any[] +>c3 : C3 + +arr_any = i1; // should be an error - is +>arr_any = i1 : I1 +>arr_any : any[] +>i1 : I1 + diff --git a/tests/baselines/reference/arrayAssignmentTest2.symbols b/tests/baselines/reference/arrayAssignmentTest2.symbols new file mode 100644 index 00000000000..e96f15fb5b1 --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest2.symbols @@ -0,0 +1,153 @@ +=== tests/cases/compiler/arrayAssignmentTest2.ts === +interface I1 { +>I1 : Symbol(I1, Decl(arrayAssignmentTest2.ts, 0, 0)) + + IM1():void[]; +>IM1 : Symbol(I1.IM1, Decl(arrayAssignmentTest2.ts, 0, 14)) +} + +class C1 implements I1 { +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest2.ts, 0, 0)) + + IM1():void[] {return null;} +>IM1 : Symbol(C1.IM1, Decl(arrayAssignmentTest2.ts, 4, 24)) + + C1M1():C1[] {return null;} +>C1M1 : Symbol(C1.C1M1, Decl(arrayAssignmentTest2.ts, 5, 28)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) + } +class C2 extends C1 { +>C2 : Symbol(C2, Decl(arrayAssignmentTest2.ts, 7, 2)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) + + C2M1():C2[] { return null;} +>C2M1 : Symbol(C2.C2M1, Decl(arrayAssignmentTest2.ts, 8, 21)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest2.ts, 7, 2)) +} + +class C3 { +>C3 : Symbol(C3, Decl(arrayAssignmentTest2.ts, 10, 1)) + + CM3M1() { return 3;} +>CM3M1 : Symbol(C3.CM3M1, Decl(arrayAssignmentTest2.ts, 12, 10)) +} + + +/* + +This behaves unexpectedly with the following types: + +Type 1 of any[]: + +* Type 2 of the following throws an error but shouldn't: () => void[], SomeClass[], and {one: 1}[]. + +* Type 2 of the following doesn't throw an error but should: {one: 1}, new() => SomeClass, SomeClass. + +*/ +var a1 : any = null; +>a1 : Symbol(a1, Decl(arrayAssignmentTest2.ts, 28, 3)) + +var c1 : C1 = new C1(); +>c1 : Symbol(c1, Decl(arrayAssignmentTest2.ts, 29, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) + +var i1 : I1 = c1; +>i1 : Symbol(i1, Decl(arrayAssignmentTest2.ts, 30, 3)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest2.ts, 0, 0)) +>c1 : Symbol(c1, Decl(arrayAssignmentTest2.ts, 29, 3)) + +var c2 : C2 = new C2(); +>c2 : Symbol(c2, Decl(arrayAssignmentTest2.ts, 31, 3)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest2.ts, 7, 2)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest2.ts, 7, 2)) + +var c3 : C3 = new C3(); +>c3 : Symbol(c3, Decl(arrayAssignmentTest2.ts, 32, 3)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest2.ts, 10, 1)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest2.ts, 10, 1)) + +var o1 = {one : 1}; +>o1 : Symbol(o1, Decl(arrayAssignmentTest2.ts, 33, 3)) +>one : Symbol(one, Decl(arrayAssignmentTest2.ts, 33, 10)) + +var f1 = function () { return new C1();} +>f1 : Symbol(f1, Decl(arrayAssignmentTest2.ts, 34, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) + +var arr_any: any[] = []; +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) + +var arr_i1: I1[] = []; +>arr_i1 : Symbol(arr_i1, Decl(arrayAssignmentTest2.ts, 37, 3)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest2.ts, 0, 0)) + +var arr_c1: C1[] = []; +>arr_c1 : Symbol(arr_c1, Decl(arrayAssignmentTest2.ts, 38, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) + +var arr_c2: C2[] = []; +>arr_c2 : Symbol(arr_c2, Decl(arrayAssignmentTest2.ts, 39, 3)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest2.ts, 7, 2)) + +var arr_i1_2: I1[] = []; +>arr_i1_2 : Symbol(arr_i1_2, Decl(arrayAssignmentTest2.ts, 40, 3)) +>I1 : Symbol(I1, Decl(arrayAssignmentTest2.ts, 0, 0)) + +var arr_c1_2: C1[] = []; +>arr_c1_2 : Symbol(arr_c1_2, Decl(arrayAssignmentTest2.ts, 41, 3)) +>C1 : Symbol(C1, Decl(arrayAssignmentTest2.ts, 2, 1)) + +var arr_c2_2: C2[] = []; +>arr_c2_2 : Symbol(arr_c2_2, Decl(arrayAssignmentTest2.ts, 42, 3)) +>C2 : Symbol(C2, Decl(arrayAssignmentTest2.ts, 7, 2)) + +var arr_c3: C3[] = []; +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest2.ts, 43, 3)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest2.ts, 10, 1)) + +// "clean up error" occurs at this point +arr_c3 = arr_c2_2; // should be an error - is +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest2.ts, 43, 3)) +>arr_c2_2 : Symbol(arr_c2_2, Decl(arrayAssignmentTest2.ts, 42, 3)) + +arr_c3 = arr_c1_2; // should be an error - is +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest2.ts, 43, 3)) +>arr_c1_2 : Symbol(arr_c1_2, Decl(arrayAssignmentTest2.ts, 41, 3)) + +arr_c3 = arr_i1_2; // should be an error - is +>arr_c3 : Symbol(arr_c3, Decl(arrayAssignmentTest2.ts, 43, 3)) +>arr_i1_2 : Symbol(arr_i1_2, Decl(arrayAssignmentTest2.ts, 40, 3)) + +arr_any = f1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) +>f1 : Symbol(f1, Decl(arrayAssignmentTest2.ts, 34, 3)) + +arr_any = function () { return null;} // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) + +arr_any = o1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) +>o1 : Symbol(o1, Decl(arrayAssignmentTest2.ts, 33, 3)) + +arr_any = a1; // should be ok - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) +>a1 : Symbol(a1, Decl(arrayAssignmentTest2.ts, 28, 3)) + +arr_any = c1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) +>c1 : Symbol(c1, Decl(arrayAssignmentTest2.ts, 29, 3)) + +arr_any = c2; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) +>c2 : Symbol(c2, Decl(arrayAssignmentTest2.ts, 31, 3)) + +arr_any = c3; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) +>c3 : Symbol(c3, Decl(arrayAssignmentTest2.ts, 32, 3)) + +arr_any = i1; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest2.ts, 36, 3)) +>i1 : Symbol(i1, Decl(arrayAssignmentTest2.ts, 30, 3)) + diff --git a/tests/baselines/reference/arrayAssignmentTest2.types b/tests/baselines/reference/arrayAssignmentTest2.types new file mode 100644 index 00000000000..86d35b06d07 --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest2.types @@ -0,0 +1,186 @@ +=== tests/cases/compiler/arrayAssignmentTest2.ts === +interface I1 { +>I1 : I1 + + IM1():void[]; +>IM1 : () => void[] +} + +class C1 implements I1 { +>C1 : C1 +>I1 : I1 + + IM1():void[] {return null;} +>IM1 : () => void[] +>null : null + + C1M1():C1[] {return null;} +>C1M1 : () => C1[] +>C1 : C1 +>null : null + } +class C2 extends C1 { +>C2 : C2 +>C1 : C1 + + C2M1():C2[] { return null;} +>C2M1 : () => C2[] +>C2 : C2 +>null : null +} + +class C3 { +>C3 : C3 + + CM3M1() { return 3;} +>CM3M1 : () => number +>3 : 3 +} + + +/* + +This behaves unexpectedly with the following types: + +Type 1 of any[]: + +* Type 2 of the following throws an error but shouldn't: () => void[], SomeClass[], and {one: 1}[]. + +* Type 2 of the following doesn't throw an error but should: {one: 1}, new() => SomeClass, SomeClass. + +*/ +var a1 : any = null; +>a1 : any +>null : null + +var c1 : C1 = new C1(); +>c1 : C1 +>C1 : C1 +>new C1() : C1 +>C1 : typeof C1 + +var i1 : I1 = c1; +>i1 : I1 +>I1 : I1 +>c1 : C1 + +var c2 : C2 = new C2(); +>c2 : C2 +>C2 : C2 +>new C2() : C2 +>C2 : typeof C2 + +var c3 : C3 = new C3(); +>c3 : C3 +>C3 : C3 +>new C3() : C3 +>C3 : typeof C3 + +var o1 = {one : 1}; +>o1 : { one: number; } +>{one : 1} : { one: number; } +>one : number +>1 : 1 + +var f1 = function () { return new C1();} +>f1 : () => C1 +>function () { return new C1();} : () => C1 +>new C1() : C1 +>C1 : typeof C1 + +var arr_any: any[] = []; +>arr_any : any[] +>[] : undefined[] + +var arr_i1: I1[] = []; +>arr_i1 : I1[] +>I1 : I1 +>[] : undefined[] + +var arr_c1: C1[] = []; +>arr_c1 : C1[] +>C1 : C1 +>[] : undefined[] + +var arr_c2: C2[] = []; +>arr_c2 : C2[] +>C2 : C2 +>[] : undefined[] + +var arr_i1_2: I1[] = []; +>arr_i1_2 : I1[] +>I1 : I1 +>[] : undefined[] + +var arr_c1_2: C1[] = []; +>arr_c1_2 : C1[] +>C1 : C1 +>[] : undefined[] + +var arr_c2_2: C2[] = []; +>arr_c2_2 : C2[] +>C2 : C2 +>[] : undefined[] + +var arr_c3: C3[] = []; +>arr_c3 : C3[] +>C3 : C3 +>[] : undefined[] + +// "clean up error" occurs at this point +arr_c3 = arr_c2_2; // should be an error - is +>arr_c3 = arr_c2_2 : C2[] +>arr_c3 : C3[] +>arr_c2_2 : C2[] + +arr_c3 = arr_c1_2; // should be an error - is +>arr_c3 = arr_c1_2 : C1[] +>arr_c3 : C3[] +>arr_c1_2 : C1[] + +arr_c3 = arr_i1_2; // should be an error - is +>arr_c3 = arr_i1_2 : I1[] +>arr_c3 : C3[] +>arr_i1_2 : I1[] + +arr_any = f1; // should be an error - is +>arr_any = f1 : () => C1 +>arr_any : any[] +>f1 : () => C1 + +arr_any = function () { return null;} // should be an error - is +>arr_any = function () { return null;} : () => any +>arr_any : any[] +>function () { return null;} : () => any +>null : null + +arr_any = o1; // should be an error - is +>arr_any = o1 : { one: number; } +>arr_any : any[] +>o1 : { one: number; } + +arr_any = a1; // should be ok - is +>arr_any = a1 : any +>arr_any : any[] +>a1 : any + +arr_any = c1; // should be an error - is +>arr_any = c1 : C1 +>arr_any : any[] +>c1 : C1 + +arr_any = c2; // should be an error - is +>arr_any = c2 : C2 +>arr_any : any[] +>c2 : C2 + +arr_any = c3; // should be an error - is +>arr_any = c3 : C3 +>arr_any : any[] +>c3 : C3 + +arr_any = i1; // should be an error - is +>arr_any = i1 : I1 +>arr_any : any[] +>i1 : I1 + diff --git a/tests/baselines/reference/arrayAssignmentTest3.symbols b/tests/baselines/reference/arrayAssignmentTest3.symbols new file mode 100644 index 00000000000..7b0907f94eb --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest3.symbols @@ -0,0 +1,25 @@ +=== tests/cases/compiler/arrayAssignmentTest3.ts === +// The following gives no error +// Michal saw no error if he used number instead of B, +// but I do... +class B {} +>B : Symbol(B, Decl(arrayAssignmentTest3.ts, 0, 0)) + +class a { +>a : Symbol(a, Decl(arrayAssignmentTest3.ts, 3, 10)) + + constructor(public x: string, public y: number, z: B[]) { } +>x : Symbol(a.x, Decl(arrayAssignmentTest3.ts, 6, 16)) +>y : Symbol(a.y, Decl(arrayAssignmentTest3.ts, 6, 33)) +>z : Symbol(z, Decl(arrayAssignmentTest3.ts, 6, 51)) +>B : Symbol(B, Decl(arrayAssignmentTest3.ts, 0, 0)) +} + + + +var xx = new a(null, 7, new B()); +>xx : Symbol(xx, Decl(arrayAssignmentTest3.ts, 11, 3)) +>a : Symbol(a, Decl(arrayAssignmentTest3.ts, 3, 10)) +>B : Symbol(B, Decl(arrayAssignmentTest3.ts, 0, 0)) + + diff --git a/tests/baselines/reference/arrayAssignmentTest3.types b/tests/baselines/reference/arrayAssignmentTest3.types new file mode 100644 index 00000000000..1a3e1e3805e --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest3.types @@ -0,0 +1,29 @@ +=== tests/cases/compiler/arrayAssignmentTest3.ts === +// The following gives no error +// Michal saw no error if he used number instead of B, +// but I do... +class B {} +>B : B + +class a { +>a : a + + constructor(public x: string, public y: number, z: B[]) { } +>x : string +>y : number +>z : B[] +>B : B +} + + + +var xx = new a(null, 7, new B()); +>xx : any +>new a(null, 7, new B()) : any +>a : typeof a +>null : null +>7 : 7 +>new B() : B +>B : typeof B + + diff --git a/tests/baselines/reference/arrayAssignmentTest4.symbols b/tests/baselines/reference/arrayAssignmentTest4.symbols new file mode 100644 index 00000000000..f8928f4ae9c --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest4.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/arrayAssignmentTest4.ts === +class C3 { +>C3 : Symbol(C3, Decl(arrayAssignmentTest4.ts, 0, 0)) + + CM3M1() { return 3;} +>CM3M1 : Symbol(C3.CM3M1, Decl(arrayAssignmentTest4.ts, 0, 10)) +} + + +/* + +This behaves unexpectedly with teh following types: + +Type 1 of any[]: + +* Type 2 of the following throws an error but shouldn't: () => void[], SomeClass[], and {one: 1}[]. + +* Type 2 of the following doesn't throw an error but should: {one: 1}, new() => SomeClass, SomeClass. + +*/ +var c3 : C3 = new C3(); +>c3 : Symbol(c3, Decl(arrayAssignmentTest4.ts, 16, 3)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest4.ts, 0, 0)) +>C3 : Symbol(C3, Decl(arrayAssignmentTest4.ts, 0, 0)) + +var o1 = {one : 1}; +>o1 : Symbol(o1, Decl(arrayAssignmentTest4.ts, 17, 3)) +>one : Symbol(one, Decl(arrayAssignmentTest4.ts, 17, 10)) + +var arr_any: any[] = []; +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest4.ts, 19, 3)) + +arr_any = function () { return null;} // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest4.ts, 19, 3)) + +arr_any = c3; // should be an error - is +>arr_any : Symbol(arr_any, Decl(arrayAssignmentTest4.ts, 19, 3)) +>c3 : Symbol(c3, Decl(arrayAssignmentTest4.ts, 16, 3)) + diff --git a/tests/baselines/reference/arrayAssignmentTest4.types b/tests/baselines/reference/arrayAssignmentTest4.types new file mode 100644 index 00000000000..c80591a8b1f --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest4.types @@ -0,0 +1,48 @@ +=== tests/cases/compiler/arrayAssignmentTest4.ts === +class C3 { +>C3 : C3 + + CM3M1() { return 3;} +>CM3M1 : () => number +>3 : 3 +} + + +/* + +This behaves unexpectedly with teh following types: + +Type 1 of any[]: + +* Type 2 of the following throws an error but shouldn't: () => void[], SomeClass[], and {one: 1}[]. + +* Type 2 of the following doesn't throw an error but should: {one: 1}, new() => SomeClass, SomeClass. + +*/ +var c3 : C3 = new C3(); +>c3 : C3 +>C3 : C3 +>new C3() : C3 +>C3 : typeof C3 + +var o1 = {one : 1}; +>o1 : { one: number; } +>{one : 1} : { one: number; } +>one : number +>1 : 1 + +var arr_any: any[] = []; +>arr_any : any[] +>[] : undefined[] + +arr_any = function () { return null;} // should be an error - is +>arr_any = function () { return null;} : () => any +>arr_any : any[] +>function () { return null;} : () => any +>null : null + +arr_any = c3; // should be an error - is +>arr_any = c3 : C3 +>arr_any : any[] +>c3 : C3 + diff --git a/tests/baselines/reference/arrayAssignmentTest5.symbols b/tests/baselines/reference/arrayAssignmentTest5.symbols new file mode 100644 index 00000000000..b85fa17ee1e --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest5.symbols @@ -0,0 +1,109 @@ +=== tests/cases/compiler/arrayAssignmentTest5.ts === +module Test { +>Test : Symbol(Test, Decl(arrayAssignmentTest5.ts, 0, 0)) + + interface IState { +>IState : Symbol(IState, Decl(arrayAssignmentTest5.ts, 0, 13)) + } + interface IToken { +>IToken : Symbol(IToken, Decl(arrayAssignmentTest5.ts, 2, 5)) + + startIndex: number; +>startIndex : Symbol(IToken.startIndex, Decl(arrayAssignmentTest5.ts, 3, 22)) + } + interface IStateToken extends IToken { +>IStateToken : Symbol(IStateToken, Decl(arrayAssignmentTest5.ts, 5, 5)) +>IToken : Symbol(IToken, Decl(arrayAssignmentTest5.ts, 2, 5)) + + state: IState; +>state : Symbol(IStateToken.state, Decl(arrayAssignmentTest5.ts, 6, 42)) +>IState : Symbol(IState, Decl(arrayAssignmentTest5.ts, 0, 13)) + } + interface ILineTokens { +>ILineTokens : Symbol(ILineTokens, Decl(arrayAssignmentTest5.ts, 8, 5)) + + tokens: IToken[]; +>tokens : Symbol(ILineTokens.tokens, Decl(arrayAssignmentTest5.ts, 9, 27)) +>IToken : Symbol(IToken, Decl(arrayAssignmentTest5.ts, 2, 5)) + + endState: IState; +>endState : Symbol(ILineTokens.endState, Decl(arrayAssignmentTest5.ts, 10, 25)) +>IState : Symbol(IState, Decl(arrayAssignmentTest5.ts, 0, 13)) + } + interface IAction { +>IAction : Symbol(IAction, Decl(arrayAssignmentTest5.ts, 12, 5)) + } + interface IMode { +>IMode : Symbol(IMode, Decl(arrayAssignmentTest5.ts, 14, 5)) + + onEnter(line:string, state:IState, offset:number):IAction; +>onEnter : Symbol(IMode.onEnter, Decl(arrayAssignmentTest5.ts, 15, 21)) +>line : Symbol(line, Decl(arrayAssignmentTest5.ts, 16, 16)) +>state : Symbol(state, Decl(arrayAssignmentTest5.ts, 16, 28)) +>IState : Symbol(IState, Decl(arrayAssignmentTest5.ts, 0, 13)) +>offset : Symbol(offset, Decl(arrayAssignmentTest5.ts, 16, 42)) +>IAction : Symbol(IAction, Decl(arrayAssignmentTest5.ts, 12, 5)) + + tokenize(line:string, state:IState, includeStates:boolean):ILineTokens; +>tokenize : Symbol(IMode.tokenize, Decl(arrayAssignmentTest5.ts, 16, 66)) +>line : Symbol(line, Decl(arrayAssignmentTest5.ts, 17, 17)) +>state : Symbol(state, Decl(arrayAssignmentTest5.ts, 17, 29)) +>IState : Symbol(IState, Decl(arrayAssignmentTest5.ts, 0, 13)) +>includeStates : Symbol(includeStates, Decl(arrayAssignmentTest5.ts, 17, 43)) +>ILineTokens : Symbol(ILineTokens, Decl(arrayAssignmentTest5.ts, 8, 5)) + } + export class Bug implements IMode { +>Bug : Symbol(Bug, Decl(arrayAssignmentTest5.ts, 18, 5)) +>IMode : Symbol(IMode, Decl(arrayAssignmentTest5.ts, 14, 5)) + + public onEnter(line:string, state:IState, offset:number):IAction { +>onEnter : Symbol(Bug.onEnter, Decl(arrayAssignmentTest5.ts, 19, 39)) +>line : Symbol(line, Decl(arrayAssignmentTest5.ts, 20, 23)) +>state : Symbol(state, Decl(arrayAssignmentTest5.ts, 20, 35)) +>IState : Symbol(IState, Decl(arrayAssignmentTest5.ts, 0, 13)) +>offset : Symbol(offset, Decl(arrayAssignmentTest5.ts, 20, 49)) +>IAction : Symbol(IAction, Decl(arrayAssignmentTest5.ts, 12, 5)) + + var lineTokens:ILineTokens= this.tokenize(line, state, true); +>lineTokens : Symbol(lineTokens, Decl(arrayAssignmentTest5.ts, 21, 15)) +>ILineTokens : Symbol(ILineTokens, Decl(arrayAssignmentTest5.ts, 8, 5)) +>this.tokenize : Symbol(Bug.tokenize, Decl(arrayAssignmentTest5.ts, 26, 9)) +>this : Symbol(Bug, Decl(arrayAssignmentTest5.ts, 18, 5)) +>tokenize : Symbol(Bug.tokenize, Decl(arrayAssignmentTest5.ts, 26, 9)) +>line : Symbol(line, Decl(arrayAssignmentTest5.ts, 20, 23)) +>state : Symbol(state, Decl(arrayAssignmentTest5.ts, 20, 35)) + + var tokens:IStateToken[]= lineTokens.tokens; +>tokens : Symbol(tokens, Decl(arrayAssignmentTest5.ts, 22, 15)) +>IStateToken : Symbol(IStateToken, Decl(arrayAssignmentTest5.ts, 5, 5)) +>lineTokens.tokens : Symbol(ILineTokens.tokens, Decl(arrayAssignmentTest5.ts, 9, 27)) +>lineTokens : Symbol(lineTokens, Decl(arrayAssignmentTest5.ts, 21, 15)) +>tokens : Symbol(ILineTokens.tokens, Decl(arrayAssignmentTest5.ts, 9, 27)) + + if (tokens.length === 0) { +>tokens.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) +>tokens : Symbol(tokens, Decl(arrayAssignmentTest5.ts, 22, 15)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) + + return this.onEnter(line, tokens, offset); // <== this should produce an error since onEnter can not be called with (string, IStateToken[], offset) +>this.onEnter : Symbol(Bug.onEnter, Decl(arrayAssignmentTest5.ts, 19, 39)) +>this : Symbol(Bug, Decl(arrayAssignmentTest5.ts, 18, 5)) +>onEnter : Symbol(Bug.onEnter, Decl(arrayAssignmentTest5.ts, 19, 39)) +>line : Symbol(line, Decl(arrayAssignmentTest5.ts, 20, 23)) +>tokens : Symbol(tokens, Decl(arrayAssignmentTest5.ts, 22, 15)) +>offset : Symbol(offset, Decl(arrayAssignmentTest5.ts, 20, 49)) + } + } + public tokenize(line:string, state:IState, includeStates:boolean):ILineTokens { +>tokenize : Symbol(Bug.tokenize, Decl(arrayAssignmentTest5.ts, 26, 9)) +>line : Symbol(line, Decl(arrayAssignmentTest5.ts, 27, 24)) +>state : Symbol(state, Decl(arrayAssignmentTest5.ts, 27, 36)) +>IState : Symbol(IState, Decl(arrayAssignmentTest5.ts, 0, 13)) +>includeStates : Symbol(includeStates, Decl(arrayAssignmentTest5.ts, 27, 50)) +>ILineTokens : Symbol(ILineTokens, Decl(arrayAssignmentTest5.ts, 8, 5)) + + return null; + } + } +} + diff --git a/tests/baselines/reference/arrayAssignmentTest5.types b/tests/baselines/reference/arrayAssignmentTest5.types new file mode 100644 index 00000000000..7e8d2e0d39b --- /dev/null +++ b/tests/baselines/reference/arrayAssignmentTest5.types @@ -0,0 +1,115 @@ +=== tests/cases/compiler/arrayAssignmentTest5.ts === +module Test { +>Test : typeof Test + + interface IState { +>IState : IState + } + interface IToken { +>IToken : IToken + + startIndex: number; +>startIndex : number + } + interface IStateToken extends IToken { +>IStateToken : IStateToken +>IToken : IToken + + state: IState; +>state : IState +>IState : IState + } + interface ILineTokens { +>ILineTokens : ILineTokens + + tokens: IToken[]; +>tokens : IToken[] +>IToken : IToken + + endState: IState; +>endState : IState +>IState : IState + } + interface IAction { +>IAction : IAction + } + interface IMode { +>IMode : IMode + + onEnter(line:string, state:IState, offset:number):IAction; +>onEnter : (line: string, state: IState, offset: number) => IAction +>line : string +>state : IState +>IState : IState +>offset : number +>IAction : IAction + + tokenize(line:string, state:IState, includeStates:boolean):ILineTokens; +>tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens +>line : string +>state : IState +>IState : IState +>includeStates : boolean +>ILineTokens : ILineTokens + } + export class Bug implements IMode { +>Bug : Bug +>IMode : IMode + + public onEnter(line:string, state:IState, offset:number):IAction { +>onEnter : (line: string, state: IState, offset: number) => IAction +>line : string +>state : IState +>IState : IState +>offset : number +>IAction : IAction + + var lineTokens:ILineTokens= this.tokenize(line, state, true); +>lineTokens : ILineTokens +>ILineTokens : ILineTokens +>this.tokenize(line, state, true) : ILineTokens +>this.tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens +>this : this +>tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens +>line : string +>state : IState +>true : true + + var tokens:IStateToken[]= lineTokens.tokens; +>tokens : IStateToken[] +>IStateToken : IStateToken +>lineTokens.tokens : IToken[] +>lineTokens : ILineTokens +>tokens : IToken[] + + if (tokens.length === 0) { +>tokens.length === 0 : boolean +>tokens.length : number +>tokens : IStateToken[] +>length : number +>0 : 0 + + return this.onEnter(line, tokens, offset); // <== this should produce an error since onEnter can not be called with (string, IStateToken[], offset) +>this.onEnter(line, tokens, offset) : IAction +>this.onEnter : (line: string, state: IState, offset: number) => IAction +>this : this +>onEnter : (line: string, state: IState, offset: number) => IAction +>line : string +>tokens : IStateToken[] +>offset : number + } + } + public tokenize(line:string, state:IState, includeStates:boolean):ILineTokens { +>tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens +>line : string +>state : IState +>IState : IState +>includeStates : boolean +>ILineTokens : ILineTokens + + return null; +>null : null + } + } +} + diff --git a/tests/baselines/reference/arrayCast.symbols b/tests/baselines/reference/arrayCast.symbols new file mode 100644 index 00000000000..668ca3a79d5 --- /dev/null +++ b/tests/baselines/reference/arrayCast.symbols @@ -0,0 +1,12 @@ +=== tests/cases/compiler/arrayCast.ts === +// Should fail. Even though the array is contextually typed with { id: number }[], it still +// has type { foo: string }[], which is not assignable to { id: number }[]. +<{ id: number; }[]>[{ foo: "s" }]; +>id : Symbol(id, Decl(arrayCast.ts, 2, 2)) +>foo : Symbol(foo, Decl(arrayCast.ts, 2, 21)) + +// Should succeed, as the {} element causes the type of the array to be {}[] +<{ id: number; }[]>[{ foo: "s" }, {}]; +>id : Symbol(id, Decl(arrayCast.ts, 5, 2)) +>foo : Symbol(foo, Decl(arrayCast.ts, 5, 21)) + diff --git a/tests/baselines/reference/arrayCast.types b/tests/baselines/reference/arrayCast.types new file mode 100644 index 00000000000..ed536d0a60a --- /dev/null +++ b/tests/baselines/reference/arrayCast.types @@ -0,0 +1,21 @@ +=== tests/cases/compiler/arrayCast.ts === +// Should fail. Even though the array is contextually typed with { id: number }[], it still +// has type { foo: string }[], which is not assignable to { id: number }[]. +<{ id: number; }[]>[{ foo: "s" }]; +><{ id: number; }[]>[{ foo: "s" }] : { id: number; }[] +>id : number +>[{ foo: "s" }] : { foo: string; }[] +>{ foo: "s" } : { foo: string; } +>foo : string +>"s" : "s" + +// Should succeed, as the {} element causes the type of the array to be {}[] +<{ id: number; }[]>[{ foo: "s" }, {}]; +><{ id: number; }[]>[{ foo: "s" }, {}] : { id: number; }[] +>id : number +>[{ foo: "s" }, {}] : ({ foo: string; } | {})[] +>{ foo: "s" } : { foo: string; } +>foo : string +>"s" : "s" +>{} : {} + diff --git a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols new file mode 100644 index 00000000000..dbe484bcf0f --- /dev/null +++ b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.symbols @@ -0,0 +1,41 @@ +=== tests/cases/compiler/arrayLiteralAndArrayConstructorEquivalence1.ts === +var myCars=new Array(); +>myCars : Symbol(myCars, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 0, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var myCars3 = new Array({}); +>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var myCars4: Array; // error +>myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var myCars5: Array[]; +>myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +myCars = myCars3; +>myCars : Symbol(myCars, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 0, 3)) +>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3)) + +myCars = myCars4; +>myCars : Symbol(myCars, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 0, 3)) +>myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 3)) + +myCars = myCars5; +>myCars : Symbol(myCars, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 0, 3)) +>myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 3)) + +myCars3 = myCars; +>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3)) +>myCars : Symbol(myCars, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 0, 3)) + +myCars3 = myCars4; +>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3)) +>myCars4 : Symbol(myCars4, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 2, 3)) + +myCars3 = myCars5; +>myCars3 : Symbol(myCars3, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 1, 3)) +>myCars5 : Symbol(myCars5, Decl(arrayLiteralAndArrayConstructorEquivalence1.ts, 3, 3)) + diff --git a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types new file mode 100644 index 00000000000..ea4803c0244 --- /dev/null +++ b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types @@ -0,0 +1,50 @@ +=== tests/cases/compiler/arrayLiteralAndArrayConstructorEquivalence1.ts === +var myCars=new Array(); +>myCars : any[] +>new Array() : any[] +>Array : ArrayConstructor + +var myCars3 = new Array({}); +>myCars3 : {}[] +>new Array({}) : {}[] +>Array : ArrayConstructor +>{} : {} + +var myCars4: Array; // error +>myCars4 : any +>Array : T[] + +var myCars5: Array[]; +>myCars5 : any[][] +>Array : T[] + +myCars = myCars3; +>myCars = myCars3 : {}[] +>myCars : any[] +>myCars3 : {}[] + +myCars = myCars4; +>myCars = myCars4 : any +>myCars : any[] +>myCars4 : any + +myCars = myCars5; +>myCars = myCars5 : any[][] +>myCars : any[] +>myCars5 : any[][] + +myCars3 = myCars; +>myCars3 = myCars : any[] +>myCars3 : {}[] +>myCars : any[] + +myCars3 = myCars4; +>myCars3 = myCars4 : any +>myCars3 : {}[] +>myCars4 : any + +myCars3 = myCars5; +>myCars3 = myCars5 : any[][] +>myCars3 : {}[] +>myCars5 : any[][] + diff --git a/tests/baselines/reference/arrayLiteralExpressionContextualTyping.symbols b/tests/baselines/reference/arrayLiteralExpressionContextualTyping.symbols new file mode 100644 index 00000000000..23458bf3636 --- /dev/null +++ b/tests/baselines/reference/arrayLiteralExpressionContextualTyping.symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/expressions/contextualTyping/arrayLiteralExpressionContextualTyping.ts === +// In a contextually typed array literal expression containing no spread elements, an element expression at index N is contextually typed by +// the type of the property with the numeric name N in the contextual type, if any, or otherwise +// the numeric index type of the contextual type, if any. +var array = [1, 2, 3]; +>array : Symbol(array, Decl(arrayLiteralExpressionContextualTyping.ts, 3, 3)) + +var array1 = [true, 2, 3]; // Contextual type by the numeric index type of the contextual type +>array1 : Symbol(array1, Decl(arrayLiteralExpressionContextualTyping.ts, 4, 3)) + +var tup: [number, number, number] = [1, 2, 3, 4]; +>tup : Symbol(tup, Decl(arrayLiteralExpressionContextualTyping.ts, 5, 3)) + +var tup1: [number|string, number|string, number|string] = [1, 2, 3, "string"]; +>tup1 : Symbol(tup1, Decl(arrayLiteralExpressionContextualTyping.ts, 6, 3)) + +var tup2: [number, number, number] = [1, 2, 3, "string"]; // Error +>tup2 : Symbol(tup2, Decl(arrayLiteralExpressionContextualTyping.ts, 7, 3)) + +// In a contextually typed array literal expression containing one or more spread elements, +// an element expression at index N is contextually typed by the numeric index type of the contextual type, if any. +var spr = [1, 2, 3, ...array]; +>spr : Symbol(spr, Decl(arrayLiteralExpressionContextualTyping.ts, 11, 3)) +>array : Symbol(array, Decl(arrayLiteralExpressionContextualTyping.ts, 3, 3)) + +var spr1 = [1, 2, 3, ...tup]; +>spr1 : Symbol(spr1, Decl(arrayLiteralExpressionContextualTyping.ts, 12, 3)) +>tup : Symbol(tup, Decl(arrayLiteralExpressionContextualTyping.ts, 5, 3)) + +var spr2:[number, number, number] = [1, 2, 3, ...tup]; // Error +>spr2 : Symbol(spr2, Decl(arrayLiteralExpressionContextualTyping.ts, 13, 3)) +>tup : Symbol(tup, Decl(arrayLiteralExpressionContextualTyping.ts, 5, 3)) + diff --git a/tests/baselines/reference/arrayLiteralExpressionContextualTyping.types b/tests/baselines/reference/arrayLiteralExpressionContextualTyping.types new file mode 100644 index 00000000000..5954448c984 --- /dev/null +++ b/tests/baselines/reference/arrayLiteralExpressionContextualTyping.types @@ -0,0 +1,71 @@ +=== tests/cases/conformance/expressions/contextualTyping/arrayLiteralExpressionContextualTyping.ts === +// In a contextually typed array literal expression containing no spread elements, an element expression at index N is contextually typed by +// the type of the property with the numeric name N in the contextual type, if any, or otherwise +// the numeric index type of the contextual type, if any. +var array = [1, 2, 3]; +>array : number[] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + +var array1 = [true, 2, 3]; // Contextual type by the numeric index type of the contextual type +>array1 : (number | boolean)[] +>[true, 2, 3] : (number | boolean)[] +>true : true +>2 : 2 +>3 : 3 + +var tup: [number, number, number] = [1, 2, 3, 4]; +>tup : [number, number, number] +>[1, 2, 3, 4] : [number, number, number, number] +>1 : 1 +>2 : 2 +>3 : 3 +>4 : 4 + +var tup1: [number|string, number|string, number|string] = [1, 2, 3, "string"]; +>tup1 : [string | number, string | number, string | number] +>[1, 2, 3, "string"] : [number, number, number, string] +>1 : 1 +>2 : 2 +>3 : 3 +>"string" : "string" + +var tup2: [number, number, number] = [1, 2, 3, "string"]; // Error +>tup2 : [number, number, number] +>[1, 2, 3, "string"] : [number, number, number, string] +>1 : 1 +>2 : 2 +>3 : 3 +>"string" : "string" + +// In a contextually typed array literal expression containing one or more spread elements, +// an element expression at index N is contextually typed by the numeric index type of the contextual type, if any. +var spr = [1, 2, 3, ...array]; +>spr : number[] +>[1, 2, 3, ...array] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>...array : number +>array : number[] + +var spr1 = [1, 2, 3, ...tup]; +>spr1 : number[] +>[1, 2, 3, ...tup] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>...tup : number +>tup : [number, number, number] + +var spr2:[number, number, number] = [1, 2, 3, ...tup]; // Error +>spr2 : [number, number, number] +>[1, 2, 3, ...tup] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>...tup : number +>tup : [number, number, number] + diff --git a/tests/baselines/reference/arrayLiteralTypeInference.symbols b/tests/baselines/reference/arrayLiteralTypeInference.symbols new file mode 100644 index 00000000000..9f95dec0aaa --- /dev/null +++ b/tests/baselines/reference/arrayLiteralTypeInference.symbols @@ -0,0 +1,113 @@ +=== tests/cases/compiler/arrayLiteralTypeInference.ts === +class Action { +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + id: number; +>id : Symbol(Action.id, Decl(arrayLiteralTypeInference.ts, 0, 14)) +} + +class ActionA extends Action { +>ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1)) +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + value: string; +>value : Symbol(ActionA.value, Decl(arrayLiteralTypeInference.ts, 4, 30)) +} + +class ActionB extends Action { +>ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1)) +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + trueNess: boolean; +>trueNess : Symbol(ActionB.trueNess, Decl(arrayLiteralTypeInference.ts, 8, 30)) +} + +var x1: Action[] = [ +>x1 : Symbol(x1, Decl(arrayLiteralTypeInference.ts, 12, 3)) +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + { id: 2, trueness: false }, +>id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 13, 5)) +>trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 13, 12)) + + { id: 3, name: "three" } +>id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 14, 5)) +>name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 14, 12)) + +] + +var x2: Action[] = [ +>x2 : Symbol(x2, Decl(arrayLiteralTypeInference.ts, 17, 3)) +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + new ActionA(), +>ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1)) + + new ActionB() +>ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1)) + +] + +var x3: Action[] = [ +>x3 : Symbol(x3, Decl(arrayLiteralTypeInference.ts, 22, 3)) +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + new Action(), +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + new ActionA(), +>ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1)) + + new ActionB() +>ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1)) + +] + +var z1: { id: number }[] = +>z1 : Symbol(z1, Decl(arrayLiteralTypeInference.ts, 28, 3)) +>id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 28, 9)) + + [ + { id: 2, trueness: false }, +>id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 30, 9)) +>trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 30, 16)) + + { id: 3, name: "three" } +>id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 31, 9)) +>name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 31, 16)) + + ] + +var z2: { id: number }[] = +>z2 : Symbol(z2, Decl(arrayLiteralTypeInference.ts, 34, 3)) +>id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 34, 9)) + + [ + new ActionA(), +>ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1)) + + new ActionB() +>ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1)) + + ] + +var z3: { id: number }[] = +>z3 : Symbol(z3, Decl(arrayLiteralTypeInference.ts, 40, 3)) +>id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 40, 9)) + + [ + new Action(), +>Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0)) + + new ActionA(), +>ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1)) + + new ActionB() +>ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1)) + + ] + + + + + diff --git a/tests/baselines/reference/arrayLiteralTypeInference.types b/tests/baselines/reference/arrayLiteralTypeInference.types new file mode 100644 index 00000000000..bb3c8b0b7de --- /dev/null +++ b/tests/baselines/reference/arrayLiteralTypeInference.types @@ -0,0 +1,144 @@ +=== tests/cases/compiler/arrayLiteralTypeInference.ts === +class Action { +>Action : Action + + id: number; +>id : number +} + +class ActionA extends Action { +>ActionA : ActionA +>Action : Action + + value: string; +>value : string +} + +class ActionB extends Action { +>ActionB : ActionB +>Action : Action + + trueNess: boolean; +>trueNess : boolean +} + +var x1: Action[] = [ +>x1 : Action[] +>Action : Action +>[ { id: 2, trueness: false }, { id: 3, name: "three" }] : ({ id: number; trueness: boolean; } | { id: number; name: string; })[] + + { id: 2, trueness: false }, +>{ id: 2, trueness: false } : { id: number; trueness: boolean; } +>id : number +>2 : 2 +>trueness : boolean +>false : false + + { id: 3, name: "three" } +>{ id: 3, name: "three" } : { id: number; name: string; } +>id : number +>3 : 3 +>name : string +>"three" : "three" + +] + +var x2: Action[] = [ +>x2 : Action[] +>Action : Action +>[ new ActionA(), new ActionB()] : (ActionA | ActionB)[] + + new ActionA(), +>new ActionA() : ActionA +>ActionA : typeof ActionA + + new ActionB() +>new ActionB() : ActionB +>ActionB : typeof ActionB + +] + +var x3: Action[] = [ +>x3 : Action[] +>Action : Action +>[ new Action(), new ActionA(), new ActionB()] : Action[] + + new Action(), +>new Action() : Action +>Action : typeof Action + + new ActionA(), +>new ActionA() : ActionA +>ActionA : typeof ActionA + + new ActionB() +>new ActionB() : ActionB +>ActionB : typeof ActionB + +] + +var z1: { id: number }[] = +>z1 : { id: number; }[] +>id : number + + [ +>[ { id: 2, trueness: false }, { id: 3, name: "three" } ] : ({ id: number; trueness: boolean; } | { id: number; name: string; })[] + + { id: 2, trueness: false }, +>{ id: 2, trueness: false } : { id: number; trueness: boolean; } +>id : number +>2 : 2 +>trueness : boolean +>false : false + + { id: 3, name: "three" } +>{ id: 3, name: "three" } : { id: number; name: string; } +>id : number +>3 : 3 +>name : string +>"three" : "three" + + ] + +var z2: { id: number }[] = +>z2 : { id: number; }[] +>id : number + + [ +>[ new ActionA(), new ActionB() ] : (ActionA | ActionB)[] + + new ActionA(), +>new ActionA() : ActionA +>ActionA : typeof ActionA + + new ActionB() +>new ActionB() : ActionB +>ActionB : typeof ActionB + + ] + +var z3: { id: number }[] = +>z3 : { id: number; }[] +>id : number + + [ +>[ new Action(), new ActionA(), new ActionB() ] : Action[] + + new Action(), +>new Action() : Action +>Action : typeof Action + + new ActionA(), +>new ActionA() : ActionA +>ActionA : typeof ActionA + + new ActionB() +>new ActionB() : ActionB +>ActionB : typeof ActionB + + ] + + + + + diff --git a/tests/baselines/reference/arrayLiterals.symbols b/tests/baselines/reference/arrayLiterals.symbols new file mode 100644 index 00000000000..0e45eaf54cf --- /dev/null +++ b/tests/baselines/reference/arrayLiterals.symbols @@ -0,0 +1,94 @@ +=== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts === +// Empty array literal with no contextual type has type Undefined[] + +var arr1= [[], [1], ['']]; +>arr1 : Symbol(arr1, Decl(arrayLiterals.ts, 2, 3)) + +var arr2 = [[null], [1], ['']]; +>arr2 : Symbol(arr2, Decl(arrayLiterals.ts, 4, 3)) + + +// Array literal with elements of only EveryType E has type E[] +var stringArrArr = [[''], [""]]; +>stringArrArr : Symbol(stringArrArr, Decl(arrayLiterals.ts, 8, 3)) + +var stringArr = ['', ""]; +>stringArr : Symbol(stringArr, Decl(arrayLiterals.ts, 10, 3)) + +var numberArr = [0, 0.0, 0x00, 1e1]; +>numberArr : Symbol(numberArr, Decl(arrayLiterals.ts, 12, 3)) + +var boolArr = [false, true, false, true]; +>boolArr : Symbol(boolArr, Decl(arrayLiterals.ts, 14, 3)) + +class C { private p; } +>C : Symbol(C, Decl(arrayLiterals.ts, 14, 41)) +>p : Symbol(C.p, Decl(arrayLiterals.ts, 16, 9)) + +var classArr = [new C(), new C()]; +>classArr : Symbol(classArr, Decl(arrayLiterals.ts, 17, 3)) +>C : Symbol(C, Decl(arrayLiterals.ts, 14, 41)) +>C : Symbol(C, Decl(arrayLiterals.ts, 14, 41)) + +var classTypeArray = [C, C, C]; +>classTypeArray : Symbol(classTypeArray, Decl(arrayLiterals.ts, 19, 3), Decl(arrayLiterals.ts, 20, 3)) +>C : Symbol(C, Decl(arrayLiterals.ts, 14, 41)) +>C : Symbol(C, Decl(arrayLiterals.ts, 14, 41)) +>C : Symbol(C, Decl(arrayLiterals.ts, 14, 41)) + +var classTypeArray: Array; // Should OK, not be a parse error +>classTypeArray : Symbol(classTypeArray, Decl(arrayLiterals.ts, 19, 3), Decl(arrayLiterals.ts, 20, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>C : Symbol(C, Decl(arrayLiterals.ts, 14, 41)) + +// Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[] +var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }]; +>context1 : Symbol(context1, Decl(arrayLiterals.ts, 23, 3)) +>n : Symbol(n, Decl(arrayLiterals.ts, 23, 17)) +>a : Symbol(a, Decl(arrayLiterals.ts, 23, 30)) +>b : Symbol(b, Decl(arrayLiterals.ts, 23, 41)) +>a : Symbol(a, Decl(arrayLiterals.ts, 23, 62)) +>b : Symbol(b, Decl(arrayLiterals.ts, 23, 69)) +>c : Symbol(c, Decl(arrayLiterals.ts, 23, 75)) +>a : Symbol(a, Decl(arrayLiterals.ts, 23, 86)) +>b : Symbol(b, Decl(arrayLiterals.ts, 23, 93)) +>c : Symbol(c, Decl(arrayLiterals.ts, 23, 99)) + +var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }]; +>context2 : Symbol(context2, Decl(arrayLiterals.ts, 24, 3)) +>a : Symbol(a, Decl(arrayLiterals.ts, 24, 17)) +>b : Symbol(b, Decl(arrayLiterals.ts, 24, 24)) +>c : Symbol(c, Decl(arrayLiterals.ts, 24, 30)) +>a : Symbol(a, Decl(arrayLiterals.ts, 24, 41)) +>b : Symbol(b, Decl(arrayLiterals.ts, 24, 48)) +>c : Symbol(c, Decl(arrayLiterals.ts, 24, 54)) + +// Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[] +class Base { private p; } +>Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63)) +>p : Symbol(Base.p, Decl(arrayLiterals.ts, 27, 12)) + +class Derived1 extends Base { private m }; +>Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25)) +>Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63)) +>m : Symbol(Derived1.m, Decl(arrayLiterals.ts, 28, 29)) + +class Derived2 extends Base { private n }; +>Derived2 : Symbol(Derived2, Decl(arrayLiterals.ts, 28, 42)) +>Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63)) +>n : Symbol(Derived2.n, Decl(arrayLiterals.ts, 29, 29)) + +var context3: Base[] = [new Derived1(), new Derived2()]; +>context3 : Symbol(context3, Decl(arrayLiterals.ts, 30, 3)) +>Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63)) +>Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25)) +>Derived2 : Symbol(Derived2, Decl(arrayLiterals.ts, 28, 42)) + +// Contextual type C with numeric index signature of type Base makes array literal of Derived1 and Derived2 have type Base[] +var context4: Base[] = [new Derived1(), new Derived1()]; +>context4 : Symbol(context4, Decl(arrayLiterals.ts, 33, 3)) +>Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63)) +>Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25)) +>Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25)) + + diff --git a/tests/baselines/reference/arrayLiterals.types b/tests/baselines/reference/arrayLiterals.types new file mode 100644 index 00000000000..02dec0c8ecd --- /dev/null +++ b/tests/baselines/reference/arrayLiterals.types @@ -0,0 +1,153 @@ +=== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts === +// Empty array literal with no contextual type has type Undefined[] + +var arr1= [[], [1], ['']]; +>arr1 : (number[] | string[])[] +>[[], [1], ['']] : (number[] | string[])[] +>[] : undefined[] +>[1] : number[] +>1 : 1 +>[''] : string[] +>'' : "" + +var arr2 = [[null], [1], ['']]; +>arr2 : (number[] | string[])[] +>[[null], [1], ['']] : (number[] | string[])[] +>[null] : null[] +>null : null +>[1] : number[] +>1 : 1 +>[''] : string[] +>'' : "" + + +// Array literal with elements of only EveryType E has type E[] +var stringArrArr = [[''], [""]]; +>stringArrArr : string[][] +>[[''], [""]] : string[][] +>[''] : string[] +>'' : "" +>[""] : string[] +>"" : "" + +var stringArr = ['', ""]; +>stringArr : string[] +>['', ""] : string[] +>'' : "" +>"" : "" + +var numberArr = [0, 0.0, 0x00, 1e1]; +>numberArr : number[] +>[0, 0.0, 0x00, 1e1] : number[] +>0 : 0 +>0.0 : 0 +>0x00 : 0 +>1e1 : 10 + +var boolArr = [false, true, false, true]; +>boolArr : boolean[] +>[false, true, false, true] : boolean[] +>false : false +>true : true +>false : false +>true : true + +class C { private p; } +>C : C +>p : any + +var classArr = [new C(), new C()]; +>classArr : C[] +>[new C(), new C()] : C[] +>new C() : C +>C : typeof C +>new C() : C +>C : typeof C + +var classTypeArray = [C, C, C]; +>classTypeArray : (typeof C)[] +>[C, C, C] : (typeof C)[] +>C : typeof C +>C : typeof C +>C : typeof C + +var classTypeArray: Array; // Should OK, not be a parse error +>classTypeArray : (typeof C)[] +>Array : T[] +>C : typeof C + +// Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[] +var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }]; +>context1 : { [n: number]: { a: string; b: number; }; } +>n : number +>a : string +>b : number +>[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[] +>{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; } +>a : string +>'' : "" +>b : number +>0 : 0 +>c : string +>'' : "" +>{ a: "", b: 3, c: 0 } : { a: string; b: number; c: number; } +>a : string +>"" : "" +>b : number +>3 : 3 +>c : number +>0 : 0 + +var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }]; +>context2 : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[] +>[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[] +>{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; } +>a : string +>'' : "" +>b : number +>0 : 0 +>c : string +>'' : "" +>{ a: "", b: 3, c: 0 } : { a: string; b: number; c: number; } +>a : string +>"" : "" +>b : number +>3 : 3 +>c : number +>0 : 0 + +// Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[] +class Base { private p; } +>Base : Base +>p : any + +class Derived1 extends Base { private m }; +>Derived1 : Derived1 +>Base : Base +>m : any + +class Derived2 extends Base { private n }; +>Derived2 : Derived2 +>Base : Base +>n : any + +var context3: Base[] = [new Derived1(), new Derived2()]; +>context3 : Base[] +>Base : Base +>[new Derived1(), new Derived2()] : (Derived1 | Derived2)[] +>new Derived1() : Derived1 +>Derived1 : typeof Derived1 +>new Derived2() : Derived2 +>Derived2 : typeof Derived2 + +// Contextual type C with numeric index signature of type Base makes array literal of Derived1 and Derived2 have type Base[] +var context4: Base[] = [new Derived1(), new Derived1()]; +>context4 : Base[] +>Base : Base +>[new Derived1(), new Derived1()] : Derived1[] +>new Derived1() : Derived1 +>Derived1 : typeof Derived1 +>new Derived1() : Derived1 +>Derived1 : typeof Derived1 + + diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols index 8202cb16df9..da256ba2238 100644 --- a/tests/baselines/reference/arrayLiterals2ES6.symbols +++ b/tests/baselines/reference/arrayLiterals2ES6.symbols @@ -79,7 +79,7 @@ interface myArray2 extends Array { } >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43)) >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) >Number : Symbol(Number, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) ->String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 1 more) var d0 = [1, true, ...temp, ]; // has type (string|number|boolean)[] >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3)) diff --git a/tests/baselines/reference/arrayLiterals3.symbols b/tests/baselines/reference/arrayLiterals3.symbols new file mode 100644 index 00000000000..8a94e9ee462 --- /dev/null +++ b/tests/baselines/reference/arrayLiterals3.symbols @@ -0,0 +1,68 @@ +=== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts === +// Each element expression in a non-empty array literal is processed as follows: +// - If the array literal contains no spread elements, and if the array literal is contextually typed (section 4.19) +// by a type T and T has a property with the numeric name N, where N is the index of the element expression in the array literal, +// the element expression is contextually typed by the type of that property. + +// The resulting type an array literal expression is determined as follows: +// - If the array literal contains no spread elements and is contextually typed by a tuple-like type, +// the resulting type is a tuple type constructed from the types of the element expressions. + +var a0: [any, any, any] = []; // Error +>a0 : Symbol(a0, Decl(arrayLiterals3.ts, 9, 3)) + +var a1: [boolean, string, number] = ["string", 1, true]; // Error +>a1 : Symbol(a1, Decl(arrayLiterals3.ts, 10, 3)) + +// The resulting type an array literal expression is determined as follows: +// - If the array literal contains no spread elements and is an array assignment pattern in a destructuring assignment (section 4.17.1), +// the resulting type is a tuple type constructed from the types of the element expressions. + +var [b1, b2]: [number, number] = [1, 2, "string", true]; +>b1 : Symbol(b1, Decl(arrayLiterals3.ts, 16, 5)) +>b2 : Symbol(b2, Decl(arrayLiterals3.ts, 16, 8)) + +// The resulting type an array literal expression is determined as follows: +// - the resulting type is an array type with an element type that is the union of the types of the +// non - spread element expressions and the numeric index signature types of the spread element expressions +var temp = ["s", "t", "r"]; +>temp : Symbol(temp, Decl(arrayLiterals3.ts, 21, 3)) + +var temp1 = [1, 2, 3]; +>temp1 : Symbol(temp1, Decl(arrayLiterals3.ts, 22, 3)) + +var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]]; +>temp2 : Symbol(temp2, Decl(arrayLiterals3.ts, 23, 3)) + +interface tup { +>tup : Symbol(tup, Decl(arrayLiterals3.ts, 23, 67)) + + 0: number[]|string[]; + 1: number[]|string[]; +} +interface myArray extends Array { } +>myArray : Symbol(myArray, Decl(arrayLiterals3.ts, 28, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +interface myArray2 extends Array { } +>myArray2 : Symbol(myArray2, Decl(arrayLiterals3.ts, 29, 43)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var c0: tup = [...temp2]; // Error +>c0 : Symbol(c0, Decl(arrayLiterals3.ts, 31, 3)) +>tup : Symbol(tup, Decl(arrayLiterals3.ts, 23, 67)) +>temp2 : Symbol(temp2, Decl(arrayLiterals3.ts, 23, 3)) + +var c1: [number, number, number] = [...temp1]; // Error cannot assign number[] to [number, number, number] +>c1 : Symbol(c1, Decl(arrayLiterals3.ts, 32, 3)) +>temp1 : Symbol(temp1, Decl(arrayLiterals3.ts, 22, 3)) + +var c2: myArray = [...temp1, ...temp]; // Error cannot assign (number|string)[] to number[] +>c2 : Symbol(c2, Decl(arrayLiterals3.ts, 33, 3)) +>myArray : Symbol(myArray, Decl(arrayLiterals3.ts, 28, 1)) +>temp1 : Symbol(temp1, Decl(arrayLiterals3.ts, 22, 3)) +>temp : Symbol(temp, Decl(arrayLiterals3.ts, 21, 3)) + diff --git a/tests/baselines/reference/arrayLiterals3.types b/tests/baselines/reference/arrayLiterals3.types new file mode 100644 index 00000000000..827f35ead8c --- /dev/null +++ b/tests/baselines/reference/arrayLiterals3.types @@ -0,0 +1,101 @@ +=== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts === +// Each element expression in a non-empty array literal is processed as follows: +// - If the array literal contains no spread elements, and if the array literal is contextually typed (section 4.19) +// by a type T and T has a property with the numeric name N, where N is the index of the element expression in the array literal, +// the element expression is contextually typed by the type of that property. + +// The resulting type an array literal expression is determined as follows: +// - If the array literal contains no spread elements and is contextually typed by a tuple-like type, +// the resulting type is a tuple type constructed from the types of the element expressions. + +var a0: [any, any, any] = []; // Error +>a0 : [any, any, any] +>[] : undefined[] + +var a1: [boolean, string, number] = ["string", 1, true]; // Error +>a1 : [boolean, string, number] +>["string", 1, true] : ["string", number, boolean] +>"string" : "string" +>1 : 1 +>true : true + +// The resulting type an array literal expression is determined as follows: +// - If the array literal contains no spread elements and is an array assignment pattern in a destructuring assignment (section 4.17.1), +// the resulting type is a tuple type constructed from the types of the element expressions. + +var [b1, b2]: [number, number] = [1, 2, "string", true]; +>b1 : number +>b2 : number +>[1, 2, "string", true] : [number, number, string, boolean] +>1 : 1 +>2 : 2 +>"string" : "string" +>true : true + +// The resulting type an array literal expression is determined as follows: +// - the resulting type is an array type with an element type that is the union of the types of the +// non - spread element expressions and the numeric index signature types of the spread element expressions +var temp = ["s", "t", "r"]; +>temp : string[] +>["s", "t", "r"] : string[] +>"s" : "s" +>"t" : "t" +>"r" : "r" + +var temp1 = [1, 2, 3]; +>temp1 : number[] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 + +var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]]; +>temp2 : [number[], string[]] +>[[1, 2, 3], ["hello", "string"]] : [number[], string[]] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>["hello", "string"] : string[] +>"hello" : "hello" +>"string" : "string" + +interface tup { +>tup : tup + + 0: number[]|string[]; + 1: number[]|string[]; +} +interface myArray extends Array { } +>myArray : myArray +>Array : T[] +>Number : Number + +interface myArray2 extends Array { } +>myArray2 : myArray2 +>Array : T[] +>Number : Number +>String : String + +var c0: tup = [...temp2]; // Error +>c0 : tup +>tup : tup +>[...temp2] : (number[] | string[])[] +>...temp2 : number[] | string[] +>temp2 : [number[], string[]] + +var c1: [number, number, number] = [...temp1]; // Error cannot assign number[] to [number, number, number] +>c1 : [number, number, number] +>[...temp1] : number[] +>...temp1 : number +>temp1 : number[] + +var c2: myArray = [...temp1, ...temp]; // Error cannot assign (number|string)[] to number[] +>c2 : myArray +>myArray : myArray +>[...temp1, ...temp] : (string | number)[] +>...temp1 : number +>temp1 : number[] +>...temp : string +>temp : string[] + diff --git a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.symbols b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.symbols new file mode 100644 index 00000000000..4c466f029ef --- /dev/null +++ b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.symbols @@ -0,0 +1,77 @@ +=== tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts === +class A { a } +>A : Symbol(A, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 0)) +>a : Symbol(A.a, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 9)) + +class B extends A { b } +>B : Symbol(B, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 13)) +>A : Symbol(A, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 0)) +>b : Symbol(B.b, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 1, 19)) + +class C extends Array { c } +>C : Symbol(C, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 1, 23)) +>T : Symbol(T, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 2, 8)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>T : Symbol(T, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 2, 8)) +>c : Symbol(C.c, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 2, 29)) + +declare var ara: A[]; +>ara : Symbol(ara, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 3, 11)) +>A : Symbol(A, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 0)) + +declare var arb: B[]; +>arb : Symbol(arb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 4, 11)) +>B : Symbol(B, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 13)) + +declare var cra: C; +>cra : Symbol(cra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 5, 11)) +>C : Symbol(C, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 1, 23)) +>A : Symbol(A, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 0)) + +declare var crb: C; +>crb : Symbol(crb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 6, 11)) +>C : Symbol(C, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 1, 23)) +>B : Symbol(B, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 13)) + +declare var rra: ReadonlyArray; +>rra : Symbol(rra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 7, 11)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.d.ts, --, --)) +>A : Symbol(A, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 0)) + +declare var rrb: ReadonlyArray; +>rrb : Symbol(rrb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 8, 11)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.d.ts, --, --)) +>B : Symbol(B, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 0, 13)) + +rra = ara; +>rra : Symbol(rra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 7, 11)) +>ara : Symbol(ara, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 3, 11)) + +rrb = arb; // OK, Array is assignable to ReadonlyArray +>rrb : Symbol(rrb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 8, 11)) +>arb : Symbol(arb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 4, 11)) + +rra = arb; +>rra : Symbol(rra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 7, 11)) +>arb : Symbol(arb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 4, 11)) + +rrb = ara; // error: 'A' is not assignable to 'B' +>rrb : Symbol(rrb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 8, 11)) +>ara : Symbol(ara, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 3, 11)) + +rra = cra; +>rra : Symbol(rra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 7, 11)) +>cra : Symbol(cra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 5, 11)) + +rra = crb; // OK, C is assignable to ReadonlyArray +>rra : Symbol(rra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 7, 11)) +>crb : Symbol(crb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 6, 11)) + +rrb = crb; +>rrb : Symbol(rrb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 8, 11)) +>crb : Symbol(crb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 6, 11)) + +rrb = cra; // error: 'A' is not assignable to 'B' +>rrb : Symbol(rrb, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 8, 11)) +>cra : Symbol(cra, Decl(arrayOfSubtypeIsAssignableToReadonlyArray.ts, 5, 11)) + diff --git a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.types b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.types new file mode 100644 index 00000000000..dea89276a58 --- /dev/null +++ b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.types @@ -0,0 +1,85 @@ +=== tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts === +class A { a } +>A : A +>a : any + +class B extends A { b } +>B : B +>A : A +>b : any + +class C extends Array { c } +>C : C +>T : T +>Array : T[] +>T : T +>c : any + +declare var ara: A[]; +>ara : A[] +>A : A + +declare var arb: B[]; +>arb : B[] +>B : B + +declare var cra: C; +>cra : C +>C : C +>A : A + +declare var crb: C; +>crb : C +>C : C +>B : B + +declare var rra: ReadonlyArray; +>rra : ReadonlyArray +>ReadonlyArray : ReadonlyArray +>A : A + +declare var rrb: ReadonlyArray; +>rrb : ReadonlyArray +>ReadonlyArray : ReadonlyArray +>B : B + +rra = ara; +>rra = ara : A[] +>rra : ReadonlyArray +>ara : A[] + +rrb = arb; // OK, Array is assignable to ReadonlyArray +>rrb = arb : B[] +>rrb : ReadonlyArray +>arb : B[] + +rra = arb; +>rra = arb : B[] +>rra : ReadonlyArray +>arb : B[] + +rrb = ara; // error: 'A' is not assignable to 'B' +>rrb = ara : A[] +>rrb : ReadonlyArray +>ara : A[] + +rra = cra; +>rra = cra : C +>rra : ReadonlyArray +>cra : C + +rra = crb; // OK, C is assignable to ReadonlyArray +>rra = crb : C +>rra : ReadonlyArray +>crb : C + +rrb = crb; +>rrb = crb : C +>rrb : ReadonlyArray +>crb : C + +rrb = cra; // error: 'A' is not assignable to 'B' +>rrb = cra : C +>rrb : ReadonlyArray +>cra : C + diff --git a/tests/baselines/reference/arrayReferenceWithoutTypeArgs.symbols b/tests/baselines/reference/arrayReferenceWithoutTypeArgs.symbols new file mode 100644 index 00000000000..b4f845f52e0 --- /dev/null +++ b/tests/baselines/reference/arrayReferenceWithoutTypeArgs.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/arrayReferenceWithoutTypeArgs.ts === +class X { +>X : Symbol(X, Decl(arrayReferenceWithoutTypeArgs.ts, 0, 0)) + + public f(a: Array) { } +>f : Symbol(X.f, Decl(arrayReferenceWithoutTypeArgs.ts, 0, 9)) +>a : Symbol(a, Decl(arrayReferenceWithoutTypeArgs.ts, 1, 13)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/arrayReferenceWithoutTypeArgs.types b/tests/baselines/reference/arrayReferenceWithoutTypeArgs.types new file mode 100644 index 00000000000..a4931c1c2cc --- /dev/null +++ b/tests/baselines/reference/arrayReferenceWithoutTypeArgs.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/arrayReferenceWithoutTypeArgs.ts === +class X { +>X : X + + public f(a: Array) { } +>f : (a: any) => void +>a : any +>Array : T[] +} diff --git a/tests/baselines/reference/arraySigChecking.symbols b/tests/baselines/reference/arraySigChecking.symbols new file mode 100644 index 00000000000..a692f78c53a --- /dev/null +++ b/tests/baselines/reference/arraySigChecking.symbols @@ -0,0 +1,76 @@ +=== tests/cases/compiler/arraySigChecking.ts === +declare module M { +>M : Symbol(M, Decl(arraySigChecking.ts, 0, 0)) + + interface iBar { t: any; } +>iBar : Symbol(iBar, Decl(arraySigChecking.ts, 0, 18)) +>t : Symbol(iBar.t, Decl(arraySigChecking.ts, 1, 20)) + + interface iFoo extends iBar { +>iFoo : Symbol(iFoo, Decl(arraySigChecking.ts, 1, 30)) +>iBar : Symbol(iBar, Decl(arraySigChecking.ts, 0, 18)) + + s: any; +>s : Symbol(iFoo.s, Decl(arraySigChecking.ts, 2, 33)) + } + + class cFoo { +>cFoo : Symbol(cFoo, Decl(arraySigChecking.ts, 4, 5)) + + t: any; +>t : Symbol(cFoo.t, Decl(arraySigChecking.ts, 6, 16)) + } + + var foo: { [index: any]; }; // expect an error here +>foo : Symbol(foo, Decl(arraySigChecking.ts, 10, 7)) +>index : Symbol(index, Decl(arraySigChecking.ts, 10, 16)) +} + +interface myInt { +>myInt : Symbol(myInt, Decl(arraySigChecking.ts, 11, 1)) + + voidFn(): void; +>voidFn : Symbol(myInt.voidFn, Decl(arraySigChecking.ts, 13, 17)) +} +var myVar: myInt; +>myVar : Symbol(myVar, Decl(arraySigChecking.ts, 16, 3)) +>myInt : Symbol(myInt, Decl(arraySigChecking.ts, 11, 1)) + +var strArray: string[] = [myVar.voidFn()]; +>strArray : Symbol(strArray, Decl(arraySigChecking.ts, 17, 3)) +>myVar.voidFn : Symbol(myInt.voidFn, Decl(arraySigChecking.ts, 13, 17)) +>myVar : Symbol(myVar, Decl(arraySigChecking.ts, 16, 3)) +>voidFn : Symbol(myInt.voidFn, Decl(arraySigChecking.ts, 13, 17)) + + +var myArray: number[][][]; +>myArray : Symbol(myArray, Decl(arraySigChecking.ts, 20, 3)) + +myArray = [[1, 2]]; +>myArray : Symbol(myArray, Decl(arraySigChecking.ts, 20, 3)) + +function isEmpty(l: { length: number }) { +>isEmpty : Symbol(isEmpty, Decl(arraySigChecking.ts, 21, 19)) +>l : Symbol(l, Decl(arraySigChecking.ts, 23, 17)) +>length : Symbol(length, Decl(arraySigChecking.ts, 23, 21)) + + return l.length === 0; +>l.length : Symbol(length, Decl(arraySigChecking.ts, 23, 21)) +>l : Symbol(l, Decl(arraySigChecking.ts, 23, 17)) +>length : Symbol(length, Decl(arraySigChecking.ts, 23, 21)) +} + +isEmpty([]); +>isEmpty : Symbol(isEmpty, Decl(arraySigChecking.ts, 21, 19)) + +isEmpty(new Array(3)); +>isEmpty : Symbol(isEmpty, Decl(arraySigChecking.ts, 21, 19)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +isEmpty(new Array(3)); +>isEmpty : Symbol(isEmpty, Decl(arraySigChecking.ts, 21, 19)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +isEmpty(['a']); +>isEmpty : Symbol(isEmpty, Decl(arraySigChecking.ts, 21, 19)) + diff --git a/tests/baselines/reference/arraySigChecking.types b/tests/baselines/reference/arraySigChecking.types new file mode 100644 index 00000000000..470e721d1bb --- /dev/null +++ b/tests/baselines/reference/arraySigChecking.types @@ -0,0 +1,96 @@ +=== tests/cases/compiler/arraySigChecking.ts === +declare module M { +>M : typeof M + + interface iBar { t: any; } +>iBar : iBar +>t : any + + interface iFoo extends iBar { +>iFoo : iFoo +>iBar : iBar + + s: any; +>s : any + } + + class cFoo { +>cFoo : cFoo + + t: any; +>t : any + } + + var foo: { [index: any]; }; // expect an error here +>foo : {} +>index : any +} + +interface myInt { +>myInt : myInt + + voidFn(): void; +>voidFn : () => void +} +var myVar: myInt; +>myVar : myInt +>myInt : myInt + +var strArray: string[] = [myVar.voidFn()]; +>strArray : string[] +>[myVar.voidFn()] : void[] +>myVar.voidFn() : void +>myVar.voidFn : () => void +>myVar : myInt +>voidFn : () => void + + +var myArray: number[][][]; +>myArray : number[][][] + +myArray = [[1, 2]]; +>myArray = [[1, 2]] : number[][] +>myArray : number[][][] +>[[1, 2]] : number[][] +>[1, 2] : number[] +>1 : 1 +>2 : 2 + +function isEmpty(l: { length: number }) { +>isEmpty : (l: { length: number; }) => boolean +>l : { length: number; } +>length : number + + return l.length === 0; +>l.length === 0 : boolean +>l.length : number +>l : { length: number; } +>length : number +>0 : 0 +} + +isEmpty([]); +>isEmpty([]) : boolean +>isEmpty : (l: { length: number; }) => boolean +>[] : undefined[] + +isEmpty(new Array(3)); +>isEmpty(new Array(3)) : boolean +>isEmpty : (l: { length: number; }) => boolean +>new Array(3) : any[] +>Array : ArrayConstructor +>3 : 3 + +isEmpty(new Array(3)); +>isEmpty(new Array(3)) : boolean +>isEmpty : (l: { length: number; }) => boolean +>new Array(3) : string[] +>Array : ArrayConstructor +>3 : 3 + +isEmpty(['a']); +>isEmpty(['a']) : boolean +>isEmpty : (l: { length: number; }) => boolean +>['a'] : string[] +>'a' : "a" + diff --git a/tests/baselines/reference/arrayTypeOfFunctionTypes.symbols b/tests/baselines/reference/arrayTypeOfFunctionTypes.symbols new file mode 100644 index 00000000000..ecd1501c662 --- /dev/null +++ b/tests/baselines/reference/arrayTypeOfFunctionTypes.symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayTypeOfFunctionTypes.ts === +// valid uses of arrays of function types + +var x: () => string[]; +>x : Symbol(x, Decl(arrayTypeOfFunctionTypes.ts, 2, 3)) + +var r = x[1]; +>r : Symbol(r, Decl(arrayTypeOfFunctionTypes.ts, 3, 3)) +>x : Symbol(x, Decl(arrayTypeOfFunctionTypes.ts, 2, 3)) + +var r2 = r(); +>r2 : Symbol(r2, Decl(arrayTypeOfFunctionTypes.ts, 4, 3)) +>r : Symbol(r, Decl(arrayTypeOfFunctionTypes.ts, 3, 3)) + +var r2b = new r(); +>r2b : Symbol(r2b, Decl(arrayTypeOfFunctionTypes.ts, 5, 3)) +>r : Symbol(r, Decl(arrayTypeOfFunctionTypes.ts, 3, 3)) + +var x2: { (): string }[]; +>x2 : Symbol(x2, Decl(arrayTypeOfFunctionTypes.ts, 7, 3)) + +var r3 = x2[1]; +>r3 : Symbol(r3, Decl(arrayTypeOfFunctionTypes.ts, 8, 3)) +>x2 : Symbol(x2, Decl(arrayTypeOfFunctionTypes.ts, 7, 3)) + +var r4 = r3(); +>r4 : Symbol(r4, Decl(arrayTypeOfFunctionTypes.ts, 9, 3)) +>r3 : Symbol(r3, Decl(arrayTypeOfFunctionTypes.ts, 8, 3)) + +var r4b = new r3(); // error +>r4b : Symbol(r4b, Decl(arrayTypeOfFunctionTypes.ts, 10, 3)) +>r3 : Symbol(r3, Decl(arrayTypeOfFunctionTypes.ts, 8, 3)) + +var x3: Array<() => string>; +>x3 : Symbol(x3, Decl(arrayTypeOfFunctionTypes.ts, 12, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var r5 = x2[1]; +>r5 : Symbol(r5, Decl(arrayTypeOfFunctionTypes.ts, 13, 3)) +>x2 : Symbol(x2, Decl(arrayTypeOfFunctionTypes.ts, 7, 3)) + +var r6 = r5(); +>r6 : Symbol(r6, Decl(arrayTypeOfFunctionTypes.ts, 14, 3)) +>r5 : Symbol(r5, Decl(arrayTypeOfFunctionTypes.ts, 13, 3)) + +var r6b = new r5(); // error +>r6b : Symbol(r6b, Decl(arrayTypeOfFunctionTypes.ts, 15, 3)) +>r5 : Symbol(r5, Decl(arrayTypeOfFunctionTypes.ts, 13, 3)) + diff --git a/tests/baselines/reference/arrayTypeOfFunctionTypes.types b/tests/baselines/reference/arrayTypeOfFunctionTypes.types new file mode 100644 index 00000000000..5248c6731c0 --- /dev/null +++ b/tests/baselines/reference/arrayTypeOfFunctionTypes.types @@ -0,0 +1,61 @@ +=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayTypeOfFunctionTypes.ts === +// valid uses of arrays of function types + +var x: () => string[]; +>x : () => string[] + +var r = x[1]; +>r : any +>x[1] : any +>x : () => string[] +>1 : 1 + +var r2 = r(); +>r2 : any +>r() : any +>r : any + +var r2b = new r(); +>r2b : any +>new r() : any +>r : any + +var x2: { (): string }[]; +>x2 : (() => string)[] + +var r3 = x2[1]; +>r3 : () => string +>x2[1] : () => string +>x2 : (() => string)[] +>1 : 1 + +var r4 = r3(); +>r4 : string +>r3() : string +>r3 : () => string + +var r4b = new r3(); // error +>r4b : any +>new r3() : any +>r3 : () => string + +var x3: Array<() => string>; +>x3 : (() => string)[] +>Array : T[] + +var r5 = x2[1]; +>r5 : () => string +>x2[1] : () => string +>x2 : (() => string)[] +>1 : 1 + +var r6 = r5(); +>r6 : string +>r5() : string +>r5 : () => string + +var r6b = new r5(); // error +>r6b : any +>new r5() : any +>r5 : () => string + diff --git a/tests/baselines/reference/arrayTypeOfFunctionTypes2.symbols b/tests/baselines/reference/arrayTypeOfFunctionTypes2.symbols new file mode 100644 index 00000000000..545546dd849 --- /dev/null +++ b/tests/baselines/reference/arrayTypeOfFunctionTypes2.symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayTypeOfFunctionTypes2.ts === +// valid uses of arrays of function types + +var x: new () => string[]; +>x : Symbol(x, Decl(arrayTypeOfFunctionTypes2.ts, 2, 3)) + +var r = x[1]; +>r : Symbol(r, Decl(arrayTypeOfFunctionTypes2.ts, 3, 3)) +>x : Symbol(x, Decl(arrayTypeOfFunctionTypes2.ts, 2, 3)) + +var r2 = new r(); +>r2 : Symbol(r2, Decl(arrayTypeOfFunctionTypes2.ts, 4, 3)) +>r : Symbol(r, Decl(arrayTypeOfFunctionTypes2.ts, 3, 3)) + +var r2b = r(); +>r2b : Symbol(r2b, Decl(arrayTypeOfFunctionTypes2.ts, 5, 3)) +>r : Symbol(r, Decl(arrayTypeOfFunctionTypes2.ts, 3, 3)) + +var x2: { new(): string }[]; +>x2 : Symbol(x2, Decl(arrayTypeOfFunctionTypes2.ts, 7, 3)) + +var r3 = x[1]; +>r3 : Symbol(r3, Decl(arrayTypeOfFunctionTypes2.ts, 8, 3)) +>x : Symbol(x, Decl(arrayTypeOfFunctionTypes2.ts, 2, 3)) + +var r4 = new r3(); +>r4 : Symbol(r4, Decl(arrayTypeOfFunctionTypes2.ts, 9, 3)) +>r3 : Symbol(r3, Decl(arrayTypeOfFunctionTypes2.ts, 8, 3)) + +var r4b = new r3(); +>r4b : Symbol(r4b, Decl(arrayTypeOfFunctionTypes2.ts, 10, 3)) +>r3 : Symbol(r3, Decl(arrayTypeOfFunctionTypes2.ts, 8, 3)) + +var x3: Array string>; +>x3 : Symbol(x3, Decl(arrayTypeOfFunctionTypes2.ts, 12, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var r5 = x2[1]; +>r5 : Symbol(r5, Decl(arrayTypeOfFunctionTypes2.ts, 13, 3)) +>x2 : Symbol(x2, Decl(arrayTypeOfFunctionTypes2.ts, 7, 3)) + +var r6 = new r5(); +>r6 : Symbol(r6, Decl(arrayTypeOfFunctionTypes2.ts, 14, 3)) +>r5 : Symbol(r5, Decl(arrayTypeOfFunctionTypes2.ts, 13, 3)) + +var r6b = r5(); +>r6b : Symbol(r6b, Decl(arrayTypeOfFunctionTypes2.ts, 15, 3)) +>r5 : Symbol(r5, Decl(arrayTypeOfFunctionTypes2.ts, 13, 3)) + diff --git a/tests/baselines/reference/arrayTypeOfFunctionTypes2.types b/tests/baselines/reference/arrayTypeOfFunctionTypes2.types new file mode 100644 index 00000000000..8ca385a71ba --- /dev/null +++ b/tests/baselines/reference/arrayTypeOfFunctionTypes2.types @@ -0,0 +1,61 @@ +=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayTypeOfFunctionTypes2.ts === +// valid uses of arrays of function types + +var x: new () => string[]; +>x : new () => string[] + +var r = x[1]; +>r : any +>x[1] : any +>x : new () => string[] +>1 : 1 + +var r2 = new r(); +>r2 : any +>new r() : any +>r : any + +var r2b = r(); +>r2b : any +>r() : any +>r : any + +var x2: { new(): string }[]; +>x2 : (new () => string)[] + +var r3 = x[1]; +>r3 : any +>x[1] : any +>x : new () => string[] +>1 : 1 + +var r4 = new r3(); +>r4 : any +>new r3() : any +>r3 : any + +var r4b = new r3(); +>r4b : any +>new r3() : any +>r3 : any + +var x3: Array string>; +>x3 : (new () => string)[] +>Array : T[] + +var r5 = x2[1]; +>r5 : new () => string +>x2[1] : new () => string +>x2 : (new () => string)[] +>1 : 1 + +var r6 = new r5(); +>r6 : string +>new r5() : string +>r5 : new () => string + +var r6b = r5(); +>r6b : any +>r5() : any +>r5 : new () => string + diff --git a/tests/baselines/reference/arrayTypeOfTypeOf.symbols b/tests/baselines/reference/arrayTypeOfTypeOf.symbols new file mode 100644 index 00000000000..b86f680b80d --- /dev/null +++ b/tests/baselines/reference/arrayTypeOfTypeOf.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayTypeOfTypeOf.ts === +// array type cannot use typeof. + +var x = 1; +>x : Symbol(x, Decl(arrayTypeOfTypeOf.ts, 2, 3)) + +var xs: typeof x[]; // Not an error. This is equivalent to Array +>xs : Symbol(xs, Decl(arrayTypeOfTypeOf.ts, 3, 3)) +>x : Symbol(x, Decl(arrayTypeOfTypeOf.ts, 2, 3)) + +var xs2: typeof Array; +>xs2 : Symbol(xs2, Decl(arrayTypeOfTypeOf.ts, 4, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var xs3: typeof Array; +>xs3 : Symbol(xs3, Decl(arrayTypeOfTypeOf.ts, 5, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var xs4: typeof Array; +>xs4 : Symbol(xs4, Decl(arrayTypeOfTypeOf.ts, 6, 3)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>x : Symbol(x, Decl(arrayTypeOfTypeOf.ts, 2, 3)) + diff --git a/tests/baselines/reference/arrayTypeOfTypeOf.types b/tests/baselines/reference/arrayTypeOfTypeOf.types new file mode 100644 index 00000000000..398cbb759a5 --- /dev/null +++ b/tests/baselines/reference/arrayTypeOfTypeOf.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayTypeOfTypeOf.ts === +// array type cannot use typeof. + +var x = 1; +>x : number +>1 : 1 + +var xs: typeof x[]; // Not an error. This is equivalent to Array +>xs : number[] +>x : number + +var xs2: typeof Array; +>xs2 : ArrayConstructor +>Array : ArrayConstructor + +var xs3: typeof Array; +>xs3 : ArrayConstructor +>Array : ArrayConstructor +> : number +> : any + +var xs4: typeof Array; +>xs4 : ArrayConstructor +>Array : ArrayConstructor +> : number +>x : number +> : any + diff --git a/tests/baselines/reference/arrowFunctionContexts.symbols b/tests/baselines/reference/arrowFunctionContexts.symbols new file mode 100644 index 00000000000..44b9aaedec4 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionContexts.symbols @@ -0,0 +1,198 @@ +=== tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts === +// Arrow function used in with statement +with (window) { + var p = () => this; +} + +// Arrow function as argument to super call +class Base { +>Base : Symbol(Base, Decl(arrowFunctionContexts.ts, 3, 1)) + + constructor(n: any) { } +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 7, 16)) +} + +class Derived extends Base { +>Derived : Symbol(Derived, Decl(arrowFunctionContexts.ts, 8, 1)) +>Base : Symbol(Base, Decl(arrowFunctionContexts.ts, 3, 1)) + + constructor() { + super(() => this); +>super : Symbol(Base, Decl(arrowFunctionContexts.ts, 3, 1)) +>this : Symbol(Derived, Decl(arrowFunctionContexts.ts, 8, 1)) + } +} + +// Arrow function as function argument +window.setTimeout(() => null, 100); + +// Arrow function as value in array literal + +var obj = (n: number) => ''; +>obj : Symbol(obj, Decl(arrowFunctionContexts.ts, 21, 3), Decl(arrowFunctionContexts.ts, 22, 3)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 21, 11)) + +var obj: { (n: number): string; }; // OK +>obj : Symbol(obj, Decl(arrowFunctionContexts.ts, 21, 3), Decl(arrowFunctionContexts.ts, 22, 3)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 22, 12)) + +var arr = [(n: number) => '']; +>arr : Symbol(arr, Decl(arrowFunctionContexts.ts, 24, 3), Decl(arrowFunctionContexts.ts, 25, 3)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 24, 12)) + +var arr: { (n: number): string; }[]; // Incorrect error here (bug 829597) +>arr : Symbol(arr, Decl(arrowFunctionContexts.ts, 24, 3), Decl(arrowFunctionContexts.ts, 25, 3)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 25, 12)) + +// Arrow function as enum value +enum E { +>E : Symbol(E, Decl(arrowFunctionContexts.ts, 25, 36)) + + x = () => 4, // Error expected +>x : Symbol(E.x, Decl(arrowFunctionContexts.ts, 28, 8)) + + y = (() => this).length // error, can't use this in enum +>y : Symbol(E.y, Decl(arrowFunctionContexts.ts, 29, 16)) +>(() => this).length : Symbol(Function.length, Decl(lib.d.ts, --, --)) +>length : Symbol(Function.length, Decl(lib.d.ts, --, --)) +} + +// Arrow function as module variable initializer +module M { +>M : Symbol(M, Decl(arrowFunctionContexts.ts, 31, 1)) + + export var a = (s) => ''; +>a : Symbol(a, Decl(arrowFunctionContexts.ts, 35, 14)) +>s : Symbol(s, Decl(arrowFunctionContexts.ts, 35, 20)) + + var b = (s) => s; +>b : Symbol(b, Decl(arrowFunctionContexts.ts, 36, 7)) +>s : Symbol(s, Decl(arrowFunctionContexts.ts, 36, 13)) +>s : Symbol(s, Decl(arrowFunctionContexts.ts, 36, 13)) +} + +// Repeat above for module members that are functions? (necessary to redo all of them?) +module M2 { +>M2 : Symbol(M2, Decl(arrowFunctionContexts.ts, 37, 1)) + + // Arrow function used in with statement + with (window) { + var p = () => this; + } + + // Arrow function as argument to super call + class Base { +>Base : Symbol(Base, Decl(arrowFunctionContexts.ts, 44, 5)) + + constructor(n: any) { } +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 48, 20)) + } + + class Derived extends Base { +>Derived : Symbol(Derived, Decl(arrowFunctionContexts.ts, 49, 5)) +>Base : Symbol(Base, Decl(arrowFunctionContexts.ts, 44, 5)) + + constructor() { + super(() => this); +>super : Symbol(Base, Decl(arrowFunctionContexts.ts, 44, 5)) +>this : Symbol(Derived, Decl(arrowFunctionContexts.ts, 49, 5)) + } + } + + // Arrow function as function argument + window.setTimeout(() => null, 100); + + // Arrow function as value in array literal + + var obj = (n: number) => ''; +>obj : Symbol(obj, Decl(arrowFunctionContexts.ts, 62, 7), Decl(arrowFunctionContexts.ts, 63, 7)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 62, 15)) + + var obj: { (n: number): string; }; // OK +>obj : Symbol(obj, Decl(arrowFunctionContexts.ts, 62, 7), Decl(arrowFunctionContexts.ts, 63, 7)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 63, 16)) + + var arr = [(n: number) => '']; +>arr : Symbol(arr, Decl(arrowFunctionContexts.ts, 65, 7), Decl(arrowFunctionContexts.ts, 66, 7)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 65, 16)) + + var arr: { (n: number): string; }[]; // Incorrect error here (bug 829597) +>arr : Symbol(arr, Decl(arrowFunctionContexts.ts, 65, 7), Decl(arrowFunctionContexts.ts, 66, 7)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 66, 16)) + + // Arrow function as enum value + enum E { +>E : Symbol(E, Decl(arrowFunctionContexts.ts, 66, 40)) + + x = () => 4, // Error expected +>x : Symbol(E.x, Decl(arrowFunctionContexts.ts, 69, 12)) + + y = (() => this).length +>y : Symbol(E.y, Decl(arrowFunctionContexts.ts, 70, 20)) +>(() => this).length : Symbol(Function.length, Decl(lib.d.ts, --, --)) +>length : Symbol(Function.length, Decl(lib.d.ts, --, --)) + } + + // Arrow function as module variable initializer + module M { +>M : Symbol(M, Decl(arrowFunctionContexts.ts, 72, 5)) + + export var a = (s) => ''; +>a : Symbol(a, Decl(arrowFunctionContexts.ts, 76, 18)) +>s : Symbol(s, Decl(arrowFunctionContexts.ts, 76, 24)) + + var b = (s) => s; +>b : Symbol(b, Decl(arrowFunctionContexts.ts, 77, 11)) +>s : Symbol(s, Decl(arrowFunctionContexts.ts, 77, 17)) +>s : Symbol(s, Decl(arrowFunctionContexts.ts, 77, 17)) + } + +} + +// (ParamList) => { ... } is a generic arrow function +var generic1 = (n: T) => [n]; +>generic1 : Symbol(generic1, Decl(arrowFunctionContexts.ts, 83, 3), Decl(arrowFunctionContexts.ts, 84, 3)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 83, 16)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 83, 19)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 83, 16)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 83, 19)) + +var generic1: { (n: T): T[] }; // Incorrect error, Bug 829597 +>generic1 : Symbol(generic1, Decl(arrowFunctionContexts.ts, 83, 3), Decl(arrowFunctionContexts.ts, 84, 3)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 84, 17)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 84, 20)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 84, 17)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 84, 17)) + +var generic2 = (n: T) => { return [n]; }; +>generic2 : Symbol(generic2, Decl(arrowFunctionContexts.ts, 85, 3), Decl(arrowFunctionContexts.ts, 86, 3)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 85, 16)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 85, 19)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 85, 16)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 85, 19)) + +var generic2: { (n: T): T[] }; +>generic2 : Symbol(generic2, Decl(arrowFunctionContexts.ts, 85, 3), Decl(arrowFunctionContexts.ts, 86, 3)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 86, 17)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 86, 20)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 86, 17)) +>T : Symbol(T, Decl(arrowFunctionContexts.ts, 86, 17)) + +// ((ParamList) => { ... } ) is a type assertion to an arrow function +var asserted1 = ((n) => [n]); +>asserted1 : Symbol(asserted1, Decl(arrowFunctionContexts.ts, 89, 3), Decl(arrowFunctionContexts.ts, 90, 3)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 89, 23)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 89, 23)) + +var asserted1: any; +>asserted1 : Symbol(asserted1, Decl(arrowFunctionContexts.ts, 89, 3), Decl(arrowFunctionContexts.ts, 90, 3)) + +var asserted2 = ((n) => { return n; }); +>asserted2 : Symbol(asserted2, Decl(arrowFunctionContexts.ts, 91, 3), Decl(arrowFunctionContexts.ts, 92, 3)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 91, 23)) +>n : Symbol(n, Decl(arrowFunctionContexts.ts, 91, 23)) + +var asserted2: any; +>asserted2 : Symbol(asserted2, Decl(arrowFunctionContexts.ts, 91, 3), Decl(arrowFunctionContexts.ts, 92, 3)) + + diff --git a/tests/baselines/reference/arrowFunctionContexts.types b/tests/baselines/reference/arrowFunctionContexts.types new file mode 100644 index 00000000000..80c310a8cd4 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionContexts.types @@ -0,0 +1,263 @@ +=== tests/cases/conformance/expressions/functions/arrowFunctionContexts.ts === +// Arrow function used in with statement +with (window) { +>window : any + + var p = () => this; +>p : any +>() => this : any +>this : any +} + +// Arrow function as argument to super call +class Base { +>Base : Base + + constructor(n: any) { } +>n : any +} + +class Derived extends Base { +>Derived : Derived +>Base : Base + + constructor() { + super(() => this); +>super(() => this) : void +>super : typeof Base +>() => this : () => this +>this : this + } +} + +// Arrow function as function argument +window.setTimeout(() => null, 100); +>window.setTimeout(() => null, 100) : any +>window.setTimeout : any +>window : any +>setTimeout : any +>() => null : () => any +>null : null +>100 : 100 + +// Arrow function as value in array literal + +var obj = (n: number) => ''; +>obj : (n: number) => string +>(n: number) => '' : (n: number) => string +>n : number +>'' : "" + +var obj: { (n: number): string; }; // OK +>obj : (n: number) => string +>n : number + +var arr = [(n: number) => '']; +>arr : ((n: number) => string)[] +>[(n: number) => ''] : ((n: number) => string)[] +>(n: number) => '' : (n: number) => string +>n : number +>'' : "" + +var arr: { (n: number): string; }[]; // Incorrect error here (bug 829597) +>arr : ((n: number) => string)[] +>n : number + +// Arrow function as enum value +enum E { +>E : E + + x = () => 4, // Error expected +>x : E +>() => 4 : () => number +>4 : 4 + + y = (() => this).length // error, can't use this in enum +>y : E +>(() => this).length : number +>(() => this) : () => any +>() => this : () => any +>this : any +>length : number +} + +// Arrow function as module variable initializer +module M { +>M : typeof M + + export var a = (s) => ''; +>a : (s: any) => string +>(s) => '' : (s: any) => string +>s : any +>'' : "" + + var b = (s) => s; +>b : (s: any) => any +>(s) => s : (s: any) => any +>s : any +>s : any +} + +// Repeat above for module members that are functions? (necessary to redo all of them?) +module M2 { +>M2 : typeof M2 + + // Arrow function used in with statement + with (window) { +>window : any + + var p = () => this; +>p : any +>() => this : any +>this : any + } + + // Arrow function as argument to super call + class Base { +>Base : Base + + constructor(n: any) { } +>n : any + } + + class Derived extends Base { +>Derived : Derived +>Base : Base + + constructor() { + super(() => this); +>super(() => this) : void +>super : typeof Base +>() => this : () => this +>this : this + } + } + + // Arrow function as function argument + window.setTimeout(() => null, 100); +>window.setTimeout(() => null, 100) : any +>window.setTimeout : any +>window : any +>setTimeout : any +>() => null : () => any +>null : null +>100 : 100 + + // Arrow function as value in array literal + + var obj = (n: number) => ''; +>obj : (n: number) => string +>(n: number) => '' : (n: number) => string +>n : number +>'' : "" + + var obj: { (n: number): string; }; // OK +>obj : (n: number) => string +>n : number + + var arr = [(n: number) => '']; +>arr : ((n: number) => string)[] +>[(n: number) => ''] : ((n: number) => string)[] +>(n: number) => '' : (n: number) => string +>n : number +>'' : "" + + var arr: { (n: number): string; }[]; // Incorrect error here (bug 829597) +>arr : ((n: number) => string)[] +>n : number + + // Arrow function as enum value + enum E { +>E : E + + x = () => 4, // Error expected +>x : E +>() => 4 : () => number +>4 : 4 + + y = (() => this).length +>y : E +>(() => this).length : number +>(() => this) : () => any +>() => this : () => any +>this : any +>length : number + } + + // Arrow function as module variable initializer + module M { +>M : typeof M + + export var a = (s) => ''; +>a : (s: any) => string +>(s) => '' : (s: any) => string +>s : any +>'' : "" + + var b = (s) => s; +>b : (s: any) => any +>(s) => s : (s: any) => any +>s : any +>s : any + } + +} + +// (ParamList) => { ... } is a generic arrow function +var generic1 = (n: T) => [n]; +>generic1 : (n: T) => T[] +>(n: T) => [n] : (n: T) => T[] +>T : T +>n : T +>T : T +>[n] : T[] +>n : T + +var generic1: { (n: T): T[] }; // Incorrect error, Bug 829597 +>generic1 : (n: T) => T[] +>T : T +>n : T +>T : T +>T : T + +var generic2 = (n: T) => { return [n]; }; +>generic2 : (n: T) => T[] +>(n: T) => { return [n]; } : (n: T) => T[] +>T : T +>n : T +>T : T +>[n] : T[] +>n : T + +var generic2: { (n: T): T[] }; +>generic2 : (n: T) => T[] +>T : T +>n : T +>T : T +>T : T + +// ((ParamList) => { ... } ) is a type assertion to an arrow function +var asserted1 = ((n) => [n]); +>asserted1 : any +>((n) => [n]) : any +>((n) => [n]) : (n: any) => any[] +>(n) => [n] : (n: any) => any[] +>n : any +>[n] : any[] +>n : any + +var asserted1: any; +>asserted1 : any + +var asserted2 = ((n) => { return n; }); +>asserted2 : any +>((n) => { return n; }) : any +>((n) => { return n; }) : (n: any) => any +>(n) => { return n; } : (n: any) => any +>n : any +>n : any + +var asserted2: any; +>asserted2 : any + + diff --git a/tests/baselines/reference/arrowFunctionErrorSpan.symbols b/tests/baselines/reference/arrowFunctionErrorSpan.symbols new file mode 100644 index 00000000000..c5adb1da8f8 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionErrorSpan.symbols @@ -0,0 +1,81 @@ +=== tests/cases/compiler/arrowFunctionErrorSpan.ts === +function f(a: () => number) { } +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) +>a : Symbol(a, Decl(arrowFunctionErrorSpan.ts, 0, 11)) + +// oneliner +f(() => { }); +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + +// multiline, body +f(() => { +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + +}); + +// multiline 2, body +f(() => { +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + +}); + +// multiline 3, arrow on a new line +f(() +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + + => { }); + +// multiline 4, arguments +f((a, +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) +>a : Symbol(a, Decl(arrowFunctionErrorSpan.ts, 20, 3)) + + b, +>b : Symbol(b, Decl(arrowFunctionErrorSpan.ts, 20, 5)) + + c, +>c : Symbol(c, Decl(arrowFunctionErrorSpan.ts, 21, 6)) + + d) => { }); +>d : Symbol(d, Decl(arrowFunctionErrorSpan.ts, 22, 6)) + +// single line with a comment +f(/* +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + + */() => { }); + +// multi line with a comment +f(/* +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + + */() => { }); + +// multi line with a comment 2 +f(/* +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + + */() => { + + }); + +// multi line with a comment 3 +f( // comment 1 +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) + + // comment 2 + () => + // comment 3 + { + // comment 4 + } + // comment 5 +); + +// body is not a block +f(_ => 1 + +>f : Symbol(f, Decl(arrowFunctionErrorSpan.ts, 0, 0)) +>_ : Symbol(_, Decl(arrowFunctionErrorSpan.ts, 51, 2)) + + 2); + diff --git a/tests/baselines/reference/arrowFunctionErrorSpan.types b/tests/baselines/reference/arrowFunctionErrorSpan.types new file mode 100644 index 00000000000..1d5bde951cd --- /dev/null +++ b/tests/baselines/reference/arrowFunctionErrorSpan.types @@ -0,0 +1,105 @@ +=== tests/cases/compiler/arrowFunctionErrorSpan.ts === +function f(a: () => number) { } +>f : (a: () => number) => void +>a : () => number + +// oneliner +f(() => { }); +>f(() => { }) : void +>f : (a: () => number) => void +>() => { } : () => void + +// multiline, body +f(() => { +>f(() => {}) : void +>f : (a: () => number) => void +>() => {} : () => void + +}); + +// multiline 2, body +f(() => { +>f(() => {}) : void +>f : (a: () => number) => void +>() => {} : () => void + +}); + +// multiline 3, arrow on a new line +f(() +>f(() => { }) : void +>f : (a: () => number) => void +>() => { } : () => void + + => { }); + +// multiline 4, arguments +f((a, +>f((a, b, c, d) => { }) : void +>f : (a: () => number) => void +>(a, b, c, d) => { } : (a: any, b: any, c: any, d: any) => void +>a : any + + b, +>b : any + + c, +>c : any + + d) => { }); +>d : any + +// single line with a comment +f(/* +>f(/* */() => { }) : void +>f : (a: () => number) => void + + */() => { }); +>() => { } : () => void + +// multi line with a comment +f(/* +>f(/* */() => { }) : void +>f : (a: () => number) => void + + */() => { }); +>() => { } : () => void + +// multi line with a comment 2 +f(/* +>f(/* */() => { }) : void +>f : (a: () => number) => void + + */() => { +>() => { } : () => void + + }); + +// multi line with a comment 3 +f( // comment 1 +>f( // comment 1 // comment 2 () => // comment 3 { // comment 4 } // comment 5) : void +>f : (a: () => number) => void + + // comment 2 + () => +>() => // comment 3 { // comment 4 } : () => void + + // comment 3 + { + // comment 4 + } + // comment 5 +); + +// body is not a block +f(_ => 1 + +>f(_ => 1 + 2) : void +>f : (a: () => number) => void +>_ => 1 + 2 : (_: any) => number +>_ : any +>1 + 2 : number +>1 : 1 + + 2); +>2 : 2 + diff --git a/tests/baselines/reference/arrowFunctionInConstructorArgument1.symbols b/tests/baselines/reference/arrowFunctionInConstructorArgument1.symbols new file mode 100644 index 00000000000..2991e8ace27 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionInConstructorArgument1.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/arrowFunctionInConstructorArgument1.ts === +class C { +>C : Symbol(C, Decl(arrowFunctionInConstructorArgument1.ts, 0, 0)) + + constructor(x: () => void) { } +>x : Symbol(x, Decl(arrowFunctionInConstructorArgument1.ts, 1, 16)) +} +var c = new C(() => { return asdf; } ) // should error +>c : Symbol(c, Decl(arrowFunctionInConstructorArgument1.ts, 3, 3)) +>C : Symbol(C, Decl(arrowFunctionInConstructorArgument1.ts, 0, 0)) + diff --git a/tests/baselines/reference/arrowFunctionInConstructorArgument1.types b/tests/baselines/reference/arrowFunctionInConstructorArgument1.types new file mode 100644 index 00000000000..bea39c33b10 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionInConstructorArgument1.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/arrowFunctionInConstructorArgument1.ts === +class C { +>C : C + + constructor(x: () => void) { } +>x : () => void +} +var c = new C(() => { return asdf; } ) // should error +>c : C +>new C(() => { return asdf; } ) : C +>C : typeof C +>() => { return asdf; } : () => any +>asdf : any + diff --git a/tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.symbols b/tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.symbols new file mode 100644 index 00000000000..af4ae1b5976 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/arrowFunctionMissingCurlyWithSemicolon.ts === +// Should error at semicolon. +var f = () => ; +>f : Symbol(f, Decl(arrowFunctionMissingCurlyWithSemicolon.ts, 1, 3)) + +var b = 1 * 2 * 3 * 4; +>b : Symbol(b, Decl(arrowFunctionMissingCurlyWithSemicolon.ts, 2, 3)) + +var square = (x: number) => x * x; +>square : Symbol(square, Decl(arrowFunctionMissingCurlyWithSemicolon.ts, 3, 3)) +>x : Symbol(x, Decl(arrowFunctionMissingCurlyWithSemicolon.ts, 3, 14)) +>x : Symbol(x, Decl(arrowFunctionMissingCurlyWithSemicolon.ts, 3, 14)) +>x : Symbol(x, Decl(arrowFunctionMissingCurlyWithSemicolon.ts, 3, 14)) + diff --git a/tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.types b/tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.types new file mode 100644 index 00000000000..90dc0011b79 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionMissingCurlyWithSemicolon.types @@ -0,0 +1,25 @@ +=== tests/cases/compiler/arrowFunctionMissingCurlyWithSemicolon.ts === +// Should error at semicolon. +var f = () => ; +>f : () => any +>() => : () => any +> : any + +var b = 1 * 2 * 3 * 4; +>b : number +>1 * 2 * 3 * 4 : number +>1 * 2 * 3 : number +>1 * 2 : number +>1 : 1 +>2 : 2 +>3 : 3 +>4 : 4 + +var square = (x: number) => x * x; +>square : (x: number) => number +>(x: number) => x * x : (x: number) => number +>x : number +>x * x : number +>x : number +>x : number + diff --git a/tests/baselines/reference/arrowFunctionsMissingTokens.symbols b/tests/baselines/reference/arrowFunctionsMissingTokens.symbols new file mode 100644 index 00000000000..31d91f71960 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionsMissingTokens.symbols @@ -0,0 +1,135 @@ +=== tests/cases/compiler/arrowFunctionsMissingTokens.ts === +module missingArrowsWithCurly { +>missingArrowsWithCurly : Symbol(missingArrowsWithCurly, Decl(arrowFunctionsMissingTokens.ts, 0, 0)) + + var a = () { }; +>a : Symbol(a, Decl(arrowFunctionsMissingTokens.ts, 1, 7)) + + var b = (): void { } +>b : Symbol(b, Decl(arrowFunctionsMissingTokens.ts, 3, 7)) + + var c = (x) { }; +>c : Symbol(c, Decl(arrowFunctionsMissingTokens.ts, 5, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 5, 13)) + + var d = (x: number, y: string) { }; +>d : Symbol(d, Decl(arrowFunctionsMissingTokens.ts, 7, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 7, 13)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 7, 23)) + + var e = (x: number, y: string): void { }; +>e : Symbol(e, Decl(arrowFunctionsMissingTokens.ts, 9, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 9, 13)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 9, 23)) +} + +module missingCurliesWithArrow { +>missingCurliesWithArrow : Symbol(missingCurliesWithArrow, Decl(arrowFunctionsMissingTokens.ts, 10, 1)) + + module withStatement { +>withStatement : Symbol(withStatement, Decl(arrowFunctionsMissingTokens.ts, 12, 32)) + + var a = () => var k = 10;}; +>a : Symbol(a, Decl(arrowFunctionsMissingTokens.ts, 14, 11)) +>k : Symbol(k, Decl(arrowFunctionsMissingTokens.ts, 14, 25)) + + var b = (): void => var k = 10;} +>b : Symbol(b, Decl(arrowFunctionsMissingTokens.ts, 16, 11)) +>k : Symbol(k, Decl(arrowFunctionsMissingTokens.ts, 16, 31)) + + var c = (x) => var k = 10;}; +>c : Symbol(c, Decl(arrowFunctionsMissingTokens.ts, 18, 11)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 18, 17)) +>k : Symbol(k, Decl(arrowFunctionsMissingTokens.ts, 18, 26)) + + var d = (x: number, y: string) => var k = 10;}; +>d : Symbol(d, Decl(arrowFunctionsMissingTokens.ts, 20, 11)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 20, 17)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 20, 27)) +>k : Symbol(k, Decl(arrowFunctionsMissingTokens.ts, 20, 45)) + + var e = (x: number, y: string): void => var k = 10;}; +>e : Symbol(e, Decl(arrowFunctionsMissingTokens.ts, 22, 11)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 22, 17)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 22, 27)) +>k : Symbol(k, Decl(arrowFunctionsMissingTokens.ts, 22, 51)) + + var f = () => var k = 10;} +>f : Symbol(f, Decl(arrowFunctionsMissingTokens.ts, 24, 11)) +>k : Symbol(k, Decl(arrowFunctionsMissingTokens.ts, 24, 25)) + } + + module withoutStatement { +>withoutStatement : Symbol(withoutStatement, Decl(arrowFunctionsMissingTokens.ts, 25, 5)) + + var a = () => }; +>a : Symbol(a, Decl(arrowFunctionsMissingTokens.ts, 28, 11)) + + var b = (): void => } +>b : Symbol(b, Decl(arrowFunctionsMissingTokens.ts, 30, 11)) + + var c = (x) => }; +>c : Symbol(c, Decl(arrowFunctionsMissingTokens.ts, 32, 11)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 32, 17)) + + var d = (x: number, y: string) => }; +>d : Symbol(d, Decl(arrowFunctionsMissingTokens.ts, 34, 11)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 34, 17)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 34, 27)) + + var e = (x: number, y: string): void => }; +>e : Symbol(e, Decl(arrowFunctionsMissingTokens.ts, 36, 11)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 36, 17)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 36, 27)) + + var f = () => } +>f : Symbol(f, Decl(arrowFunctionsMissingTokens.ts, 38, 11)) + } +} + +module ce_nEst_pas_une_arrow_function { +>ce_nEst_pas_une_arrow_function : Symbol(ce_nEst_pas_une_arrow_function, Decl(arrowFunctionsMissingTokens.ts, 40, 1)) + + var a = (); +>a : Symbol(a, Decl(arrowFunctionsMissingTokens.ts, 43, 7)) + + var b = (): void; +>b : Symbol(b, Decl(arrowFunctionsMissingTokens.ts, 45, 7)) + + var c = (x); +>c : Symbol(c, Decl(arrowFunctionsMissingTokens.ts, 47, 7)) + + var d = (x: number, y: string); +>d : Symbol(d, Decl(arrowFunctionsMissingTokens.ts, 49, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 49, 13)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 49, 23)) + + var e = (x: number, y: string): void; +>e : Symbol(e, Decl(arrowFunctionsMissingTokens.ts, 51, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 51, 13)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 51, 23)) +} + +module okay { +>okay : Symbol(okay, Decl(arrowFunctionsMissingTokens.ts, 52, 1)) + + var a = () => { }; +>a : Symbol(a, Decl(arrowFunctionsMissingTokens.ts, 55, 7)) + + var b = (): void => { } +>b : Symbol(b, Decl(arrowFunctionsMissingTokens.ts, 57, 7)) + + var c = (x) => { }; +>c : Symbol(c, Decl(arrowFunctionsMissingTokens.ts, 59, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 59, 13)) + + var d = (x: number, y: string) => { }; +>d : Symbol(d, Decl(arrowFunctionsMissingTokens.ts, 61, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 61, 13)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 61, 23)) + + var e = (x: number, y: string): void => { }; +>e : Symbol(e, Decl(arrowFunctionsMissingTokens.ts, 63, 7)) +>x : Symbol(x, Decl(arrowFunctionsMissingTokens.ts, 63, 13)) +>y : Symbol(y, Decl(arrowFunctionsMissingTokens.ts, 63, 23)) +} diff --git a/tests/baselines/reference/arrowFunctionsMissingTokens.types b/tests/baselines/reference/arrowFunctionsMissingTokens.types new file mode 100644 index 00000000000..ab067bb1415 --- /dev/null +++ b/tests/baselines/reference/arrowFunctionsMissingTokens.types @@ -0,0 +1,179 @@ +=== tests/cases/compiler/arrowFunctionsMissingTokens.ts === +module missingArrowsWithCurly { +>missingArrowsWithCurly : typeof missingArrowsWithCurly + + var a = () { }; +>a : () => void +>() { } : () => void + + var b = (): void { } +>b : () => void +>(): void { } : () => void + + var c = (x) { }; +>c : (x: any) => void +>(x) { } : (x: any) => void +>x : any + + var d = (x: number, y: string) { }; +>d : (x: number, y: string) => void +>(x: number, y: string) { } : (x: number, y: string) => void +>x : number +>y : string + + var e = (x: number, y: string): void { }; +>e : (x: number, y: string) => void +>(x: number, y: string): void { } : (x: number, y: string) => void +>x : number +>y : string +} + +module missingCurliesWithArrow { +>missingCurliesWithArrow : typeof missingCurliesWithArrow + + module withStatement { +>withStatement : typeof withStatement + + var a = () => var k = 10;}; +>a : () => void +>() => var k = 10;} : () => void +>k : number +>10 : 10 + + var b = (): void => var k = 10;} +>b : () => void +>(): void => var k = 10;} : () => void +>k : number +>10 : 10 + + var c = (x) => var k = 10;}; +>c : (x: any) => void +>(x) => var k = 10;} : (x: any) => void +>x : any +>k : number +>10 : 10 + + var d = (x: number, y: string) => var k = 10;}; +>d : (x: number, y: string) => void +>(x: number, y: string) => var k = 10;} : (x: number, y: string) => void +>x : number +>y : string +>k : number +>10 : 10 + + var e = (x: number, y: string): void => var k = 10;}; +>e : (x: number, y: string) => void +>(x: number, y: string): void => var k = 10;} : (x: number, y: string) => void +>x : number +>y : string +>k : number +>10 : 10 + + var f = () => var k = 10;} +>f : () => void +>() => var k = 10;} : () => void +>k : number +>10 : 10 + } + + module withoutStatement { +>withoutStatement : typeof withoutStatement + + var a = () => }; +>a : () => any +>() => : () => any +> : any + + var b = (): void => } +>b : () => void +>(): void => : () => void +> : any + + var c = (x) => }; +>c : (x: any) => any +>(x) => : (x: any) => any +>x : any +> : any + + var d = (x: number, y: string) => }; +>d : (x: number, y: string) => any +>(x: number, y: string) => : (x: number, y: string) => any +>x : number +>y : string +> : any + + var e = (x: number, y: string): void => }; +>e : (x: number, y: string) => void +>(x: number, y: string): void => : (x: number, y: string) => void +>x : number +>y : string +> : any + + var f = () => } +>f : () => any +>() => : () => any +> : any + } +} + +module ce_nEst_pas_une_arrow_function { +>ce_nEst_pas_une_arrow_function : typeof ce_nEst_pas_une_arrow_function + + var a = (); +>a : any +>() : any +> : any + + var b = (): void; +>b : () => void +>(): void : () => void +> : any + + var c = (x); +>c : any +>(x) : any +>x : any + + var d = (x: number, y: string); +>d : (x: number, y: string) => any +>(x: number, y: string) : (x: number, y: string) => any +>x : number +>y : string +> : any + + var e = (x: number, y: string): void; +>e : (x: number, y: string) => void +>(x: number, y: string): void : (x: number, y: string) => void +>x : number +>y : string +> : any +} + +module okay { +>okay : typeof okay + + var a = () => { }; +>a : () => void +>() => { } : () => void + + var b = (): void => { } +>b : () => void +>(): void => { } : () => void + + var c = (x) => { }; +>c : (x: any) => void +>(x) => { } : (x: any) => void +>x : any + + var d = (x: number, y: string) => { }; +>d : (x: number, y: string) => void +>(x: number, y: string) => { } : (x: number, y: string) => void +>x : number +>y : string + + var e = (x: number, y: string): void => { }; +>e : (x: number, y: string) => void +>(x: number, y: string): void => { } : (x: number, y: string) => void +>x : number +>y : string +} diff --git a/tests/baselines/reference/asOperator2.symbols b/tests/baselines/reference/asOperator2.symbols new file mode 100644 index 00000000000..52ddf48e2e7 --- /dev/null +++ b/tests/baselines/reference/asOperator2.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/expressions/asOperator/asOperator2.ts === +var x = 23 as string; +>x : Symbol(x, Decl(asOperator2.ts, 0, 3)) + diff --git a/tests/baselines/reference/asOperator2.types b/tests/baselines/reference/asOperator2.types new file mode 100644 index 00000000000..108b97a1d85 --- /dev/null +++ b/tests/baselines/reference/asOperator2.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/expressions/asOperator/asOperator2.ts === +var x = 23 as string; +>x : string +>23 as string : string +>23 : 23 + diff --git a/tests/baselines/reference/asOperatorAmbiguity.symbols b/tests/baselines/reference/asOperatorAmbiguity.symbols new file mode 100644 index 00000000000..d191f110b3b --- /dev/null +++ b/tests/baselines/reference/asOperatorAmbiguity.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts === +interface A { x: T; } +>A : Symbol(A, Decl(asOperatorAmbiguity.ts, 0, 0)) +>T : Symbol(T, Decl(asOperatorAmbiguity.ts, 0, 12)) +>x : Symbol(A.x, Decl(asOperatorAmbiguity.ts, 0, 16)) +>T : Symbol(T, Decl(asOperatorAmbiguity.ts, 0, 12)) + +interface B { m: string; } +>B : Symbol(B, Decl(asOperatorAmbiguity.ts, 0, 24)) +>m : Symbol(B.m, Decl(asOperatorAmbiguity.ts, 1, 13)) + +// Make sure this is a type assertion to an array type, and not nested comparison operators. +var x: any; +>x : Symbol(x, Decl(asOperatorAmbiguity.ts, 4, 3)) + +var y = x as A[]; +>y : Symbol(y, Decl(asOperatorAmbiguity.ts, 5, 3)) +>x : Symbol(x, Decl(asOperatorAmbiguity.ts, 4, 3)) +>A : Symbol(A, Decl(asOperatorAmbiguity.ts, 0, 0)) +>B : Symbol(B, Decl(asOperatorAmbiguity.ts, 0, 24)) + +var z = y[0].m; // z should be string +>z : Symbol(z, Decl(asOperatorAmbiguity.ts, 6, 3)) +>y : Symbol(y, Decl(asOperatorAmbiguity.ts, 5, 3)) + + diff --git a/tests/baselines/reference/asOperatorAmbiguity.types b/tests/baselines/reference/asOperatorAmbiguity.types new file mode 100644 index 00000000000..61aa0f00e66 --- /dev/null +++ b/tests/baselines/reference/asOperatorAmbiguity.types @@ -0,0 +1,31 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorAmbiguity.ts === +interface A { x: T; } +>A : A +>T : T +>x : T +>T : T + +interface B { m: string; } +>B : B +>m : string + +// Make sure this is a type assertion to an array type, and not nested comparison operators. +var x: any; +>x : any + +var y = x as A[]; +>y : A[] +>x as A[] : A[] +>x : any +>A : A +>B : B + +var z = y[0].m; // z should be string +>z : any +>y[0].m : any +>y[0] : A +>y : A[] +>0 : 0 +>m : any + + diff --git a/tests/baselines/reference/asOperatorContextualType.symbols b/tests/baselines/reference/asOperatorContextualType.symbols new file mode 100644 index 00000000000..b32284b5393 --- /dev/null +++ b/tests/baselines/reference/asOperatorContextualType.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts === +// should error +var x = (v => v) as (x: number) => string; +>x : Symbol(x, Decl(asOperatorContextualType.ts, 1, 3)) +>v : Symbol(v, Decl(asOperatorContextualType.ts, 1, 9)) +>v : Symbol(v, Decl(asOperatorContextualType.ts, 1, 9)) +>x : Symbol(x, Decl(asOperatorContextualType.ts, 1, 21)) + diff --git a/tests/baselines/reference/asOperatorContextualType.types b/tests/baselines/reference/asOperatorContextualType.types new file mode 100644 index 00000000000..b318dd4878b --- /dev/null +++ b/tests/baselines/reference/asOperatorContextualType.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorContextualType.ts === +// should error +var x = (v => v) as (x: number) => string; +>x : (x: number) => string +>(v => v) as (x: number) => string : (x: number) => string +>(v => v) : (v: number) => number +>v => v : (v: number) => number +>v : number +>v : number +>x : number + diff --git a/tests/baselines/reference/asOperatorNames.symbols b/tests/baselines/reference/asOperatorNames.symbols new file mode 100644 index 00000000000..eda84b98c24 --- /dev/null +++ b/tests/baselines/reference/asOperatorNames.symbols @@ -0,0 +1,15 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorNames.ts === +var a = 20; +>a : Symbol(a, Decl(asOperatorNames.ts, 0, 3)) + +var b = a as string; +>b : Symbol(b, Decl(asOperatorNames.ts, 1, 3)) +>a : Symbol(a, Decl(asOperatorNames.ts, 0, 3)) + +var as = "hello"; +>as : Symbol(as, Decl(asOperatorNames.ts, 2, 3)) + +var as1 = as as string; +>as1 : Symbol(as1, Decl(asOperatorNames.ts, 3, 3)) +>as : Symbol(as, Decl(asOperatorNames.ts, 2, 3)) + diff --git a/tests/baselines/reference/asOperatorNames.types b/tests/baselines/reference/asOperatorNames.types new file mode 100644 index 00000000000..0caa81d1f8d --- /dev/null +++ b/tests/baselines/reference/asOperatorNames.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/expressions/asOperator/asOperatorNames.ts === +var a = 20; +>a : number +>20 : 20 + +var b = a as string; +>b : string +>a as string : string +>a : number + +var as = "hello"; +>as : string +>"hello" : "hello" + +var as1 = as as string; +>as1 : string +>as as string : string +>as : string + diff --git a/tests/baselines/reference/asiAbstract.symbols b/tests/baselines/reference/asiAbstract.symbols new file mode 100644 index 00000000000..d7781af6495 --- /dev/null +++ b/tests/baselines/reference/asiAbstract.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/asiAbstract.ts === +abstract +class NonAbstractClass { +>NonAbstractClass : Symbol(NonAbstractClass, Decl(asiAbstract.ts, 0, 8)) + + abstract s(); +>s : Symbol(NonAbstractClass.s, Decl(asiAbstract.ts, 1, 24)) +} + +class C2 { +>C2 : Symbol(C2, Decl(asiAbstract.ts, 3, 1)) + + abstract +>abstract : Symbol(C2.abstract, Decl(asiAbstract.ts, 5, 10)) + + nonAbstractFunction() { +>nonAbstractFunction : Symbol(C2.nonAbstractFunction, Decl(asiAbstract.ts, 6, 12)) + } +} + +class C3 { +>C3 : Symbol(C3, Decl(asiAbstract.ts, 9, 1)) + + abstract +>abstract : Symbol(C3.abstract, Decl(asiAbstract.ts, 11, 10)) +} + diff --git a/tests/baselines/reference/asiAbstract.types b/tests/baselines/reference/asiAbstract.types new file mode 100644 index 00000000000..d1ac88d5373 --- /dev/null +++ b/tests/baselines/reference/asiAbstract.types @@ -0,0 +1,29 @@ +=== tests/cases/compiler/asiAbstract.ts === +abstract +>abstract : any + +class NonAbstractClass { +>NonAbstractClass : NonAbstractClass + + abstract s(); +>s : () => any +} + +class C2 { +>C2 : C2 + + abstract +>abstract : any + + nonAbstractFunction() { +>nonAbstractFunction : () => void + } +} + +class C3 { +>C3 : C3 + + abstract +>abstract : any +} + diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface05.symbols b/tests/baselines/reference/asiPreventsParsingAsInterface05.symbols new file mode 100644 index 00000000000..08eddcb1d78 --- /dev/null +++ b/tests/baselines/reference/asiPreventsParsingAsInterface05.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface05.ts === +"use strict" + +var interface: number; +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface05.ts, 2, 3)) + +// 'interface' is a strict mode reserved word, and so it would be permissible +// to allow 'interface' and the name of the interface to be on separate lines; +// however, this complicates things, and so it is preferable to restrict interface +// declarations such that their identifier must follow 'interface' on the same line. + +interface // This should be the identifier 'interface' +>interface : Symbol(interface, Decl(asiPreventsParsingAsInterface05.ts, 2, 3)) + +I // This should be the identifier 'I' +{ } // This should be a block body diff --git a/tests/baselines/reference/asiPreventsParsingAsInterface05.types b/tests/baselines/reference/asiPreventsParsingAsInterface05.types new file mode 100644 index 00000000000..3cd12ce04b3 --- /dev/null +++ b/tests/baselines/reference/asiPreventsParsingAsInterface05.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/interfaces/interfaceDeclarations/asiPreventsParsingAsInterface05.ts === +"use strict" +>"use strict" : "use strict" + +var interface: number; +>interface : number + +// 'interface' is a strict mode reserved word, and so it would be permissible +// to allow 'interface' and the name of the interface to be on separate lines; +// however, this complicates things, and so it is preferable to restrict interface +// declarations such that their identifier must follow 'interface' on the same line. + +interface // This should be the identifier 'interface' +>interface : number + +I // This should be the identifier 'I' +>I : any + +{ } // This should be a block body diff --git a/tests/baselines/reference/asiPublicPrivateProtected.symbols b/tests/baselines/reference/asiPublicPrivateProtected.symbols new file mode 100644 index 00000000000..987849a329a --- /dev/null +++ b/tests/baselines/reference/asiPublicPrivateProtected.symbols @@ -0,0 +1,72 @@ +=== tests/cases/compiler/asiPublicPrivateProtected.ts === +public +class NonPublicClass { +>NonPublicClass : Symbol(NonPublicClass, Decl(asiPublicPrivateProtected.ts, 0, 6)) + + public s() { +>s : Symbol(NonPublicClass.s, Decl(asiPublicPrivateProtected.ts, 1, 22)) + } +} + +class NonPublicClass2 { +>NonPublicClass2 : Symbol(NonPublicClass2, Decl(asiPublicPrivateProtected.ts, 4, 1)) + + public +>public : Symbol(NonPublicClass2.public, Decl(asiPublicPrivateProtected.ts, 6, 23)) + + private nonPublicFunction() { +>nonPublicFunction : Symbol(NonPublicClass2.nonPublicFunction, Decl(asiPublicPrivateProtected.ts, 7, 10)) + } +} +private +class NonPrivateClass { +>NonPrivateClass : Symbol(NonPrivateClass, Decl(asiPublicPrivateProtected.ts, 11, 7)) + + private s() { +>s : Symbol(NonPrivateClass.s, Decl(asiPublicPrivateProtected.ts, 12, 23)) + } +} + +class NonPrivateClass2 { +>NonPrivateClass2 : Symbol(NonPrivateClass2, Decl(asiPublicPrivateProtected.ts, 15, 1)) + + private +>private : Symbol(NonPrivateClass2.private, Decl(asiPublicPrivateProtected.ts, 17, 24)) + + public nonPrivateFunction() { +>nonPrivateFunction : Symbol(NonPrivateClass2.nonPrivateFunction, Decl(asiPublicPrivateProtected.ts, 18, 11)) + } +} +protected +class NonProtectedClass { +>NonProtectedClass : Symbol(NonProtectedClass, Decl(asiPublicPrivateProtected.ts, 22, 9)) + + protected s() { +>s : Symbol(NonProtectedClass.s, Decl(asiPublicPrivateProtected.ts, 23, 25)) + } +} + +class NonProtectedClass2 { +>NonProtectedClass2 : Symbol(NonProtectedClass2, Decl(asiPublicPrivateProtected.ts, 26, 1)) + + protected +>protected : Symbol(NonProtectedClass2.protected, Decl(asiPublicPrivateProtected.ts, 28, 26)) + + public nonProtectedFunction() { +>nonProtectedFunction : Symbol(NonProtectedClass2.nonProtectedFunction, Decl(asiPublicPrivateProtected.ts, 29, 13)) + } +} + +class ClassWithThreeMembers { +>ClassWithThreeMembers : Symbol(ClassWithThreeMembers, Decl(asiPublicPrivateProtected.ts, 32, 1)) + + public +>public : Symbol(ClassWithThreeMembers.public, Decl(asiPublicPrivateProtected.ts, 34, 29)) + + private +>private : Symbol(ClassWithThreeMembers.private, Decl(asiPublicPrivateProtected.ts, 35, 10)) + + protected +>protected : Symbol(ClassWithThreeMembers.protected, Decl(asiPublicPrivateProtected.ts, 36, 11)) +} + diff --git a/tests/baselines/reference/asiPublicPrivateProtected.types b/tests/baselines/reference/asiPublicPrivateProtected.types new file mode 100644 index 00000000000..c1734d8488d --- /dev/null +++ b/tests/baselines/reference/asiPublicPrivateProtected.types @@ -0,0 +1,78 @@ +=== tests/cases/compiler/asiPublicPrivateProtected.ts === +public +>public : any + +class NonPublicClass { +>NonPublicClass : NonPublicClass + + public s() { +>s : () => void + } +} + +class NonPublicClass2 { +>NonPublicClass2 : NonPublicClass2 + + public +>public : any + + private nonPublicFunction() { +>nonPublicFunction : () => void + } +} +private +>private : any + +class NonPrivateClass { +>NonPrivateClass : NonPrivateClass + + private s() { +>s : () => void + } +} + +class NonPrivateClass2 { +>NonPrivateClass2 : NonPrivateClass2 + + private +>private : any + + public nonPrivateFunction() { +>nonPrivateFunction : () => void + } +} +protected +>protected : any + +class NonProtectedClass { +>NonProtectedClass : NonProtectedClass + + protected s() { +>s : () => void + } +} + +class NonProtectedClass2 { +>NonProtectedClass2 : NonProtectedClass2 + + protected +>protected : any + + public nonProtectedFunction() { +>nonProtectedFunction : () => void + } +} + +class ClassWithThreeMembers { +>ClassWithThreeMembers : ClassWithThreeMembers + + public +>public : any + + private +>private : any + + protected +>protected : any +} + diff --git a/tests/baselines/reference/asiReturn.symbols b/tests/baselines/reference/asiReturn.symbols new file mode 100644 index 00000000000..da206e8577b --- /dev/null +++ b/tests/baselines/reference/asiReturn.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/asiReturn.ts === +// This should be an error for using a return outside a function, but ASI should work properly +No type information for this code.return +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/asiReturn.types b/tests/baselines/reference/asiReturn.types new file mode 100644 index 00000000000..da206e8577b --- /dev/null +++ b/tests/baselines/reference/asiReturn.types @@ -0,0 +1,4 @@ +=== tests/cases/compiler/asiReturn.ts === +// This should be an error for using a return outside a function, but ASI should work properly +No type information for this code.return +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/assertInWrapSomeTypeParameter.symbols b/tests/baselines/reference/assertInWrapSomeTypeParameter.symbols new file mode 100644 index 00000000000..c2079508930 --- /dev/null +++ b/tests/baselines/reference/assertInWrapSomeTypeParameter.symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/assertInWrapSomeTypeParameter.ts === +class C> { +>C : Symbol(C, Decl(assertInWrapSomeTypeParameter.ts, 0, 0)) +>T : Symbol(T, Decl(assertInWrapSomeTypeParameter.ts, 0, 8)) +>C : Symbol(C, Decl(assertInWrapSomeTypeParameter.ts, 0, 0)) +>T : Symbol(T, Decl(assertInWrapSomeTypeParameter.ts, 0, 8)) + + foo>(x: U) { +>foo : Symbol(C.foo, Decl(assertInWrapSomeTypeParameter.ts, 0, 25)) +>U : Symbol(U, Decl(assertInWrapSomeTypeParameter.ts, 1, 8)) +>C : Symbol(C, Decl(assertInWrapSomeTypeParameter.ts, 0, 0)) +>C : Symbol(C, Decl(assertInWrapSomeTypeParameter.ts, 0, 0)) +>T : Symbol(T, Decl(assertInWrapSomeTypeParameter.ts, 0, 8)) +>x : Symbol(x, Decl(assertInWrapSomeTypeParameter.ts, 1, 26)) +>U : Symbol(U, Decl(assertInWrapSomeTypeParameter.ts, 1, 8)) + + return null; + } +} diff --git a/tests/baselines/reference/assertInWrapSomeTypeParameter.types b/tests/baselines/reference/assertInWrapSomeTypeParameter.types new file mode 100644 index 00000000000..289001b6c3a --- /dev/null +++ b/tests/baselines/reference/assertInWrapSomeTypeParameter.types @@ -0,0 +1,20 @@ +=== tests/cases/compiler/assertInWrapSomeTypeParameter.ts === +class C> { +>C : C +>T : T +>C : C +>T : T + + foo>(x: U) { +>foo : >>(x: U) => any +>U : U +>C : C +>C : C +>T : T +>x : U +>U : U + + return null; +>null : null + } +} diff --git a/tests/baselines/reference/assignAnyToEveryType.symbols b/tests/baselines/reference/assignAnyToEveryType.symbols new file mode 100644 index 00000000000..c5f6addb2fa --- /dev/null +++ b/tests/baselines/reference/assignAnyToEveryType.symbols @@ -0,0 +1,115 @@ +=== tests/cases/conformance/types/any/assignAnyToEveryType.ts === +// all of these are valid + +var x: any; +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var a: number = x; +>a : Symbol(a, Decl(assignAnyToEveryType.ts, 4, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var b: boolean = x; +>b : Symbol(b, Decl(assignAnyToEveryType.ts, 5, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var c: string = x; +>c : Symbol(c, Decl(assignAnyToEveryType.ts, 6, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var d: void = x; +>d : Symbol(d, Decl(assignAnyToEveryType.ts, 7, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var e = null; +>e : Symbol(e, Decl(assignAnyToEveryType.ts, 8, 3)) + +e = x; +>e : Symbol(e, Decl(assignAnyToEveryType.ts, 8, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var f = undefined; +>f : Symbol(f, Decl(assignAnyToEveryType.ts, 10, 3)) +>undefined : Symbol(undefined) + +f = x; +>f : Symbol(f, Decl(assignAnyToEveryType.ts, 10, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +enum E { +>E : Symbol(E, Decl(assignAnyToEveryType.ts, 11, 6)) + + A +>A : Symbol(E.A, Decl(assignAnyToEveryType.ts, 13, 8)) +} + +var g: E = x; +>g : Symbol(g, Decl(assignAnyToEveryType.ts, 17, 3)) +>E : Symbol(E, Decl(assignAnyToEveryType.ts, 11, 6)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var g2 = E.A; +>g2 : Symbol(g2, Decl(assignAnyToEveryType.ts, 18, 3)) +>E.A : Symbol(E.A, Decl(assignAnyToEveryType.ts, 13, 8)) +>E : Symbol(E, Decl(assignAnyToEveryType.ts, 11, 6)) +>A : Symbol(E.A, Decl(assignAnyToEveryType.ts, 13, 8)) + +g2 = x; +>g2 : Symbol(g2, Decl(assignAnyToEveryType.ts, 18, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +class C { +>C : Symbol(C, Decl(assignAnyToEveryType.ts, 19, 7)) + + foo: string; +>foo : Symbol(C.foo, Decl(assignAnyToEveryType.ts, 21, 9)) +} + +var h: C = x; +>h : Symbol(h, Decl(assignAnyToEveryType.ts, 25, 3)) +>C : Symbol(C, Decl(assignAnyToEveryType.ts, 19, 7)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +interface I { +>I : Symbol(I, Decl(assignAnyToEveryType.ts, 25, 13)) + + foo: string; +>foo : Symbol(I.foo, Decl(assignAnyToEveryType.ts, 27, 13)) +} + +var i: I = x; +>i : Symbol(i, Decl(assignAnyToEveryType.ts, 31, 3)) +>I : Symbol(I, Decl(assignAnyToEveryType.ts, 25, 13)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var j: { (): string } = x; +>j : Symbol(j, Decl(assignAnyToEveryType.ts, 33, 3)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +var j2: { (x: T): string } = x; +>j2 : Symbol(j2, Decl(assignAnyToEveryType.ts, 34, 3)) +>T : Symbol(T, Decl(assignAnyToEveryType.ts, 34, 11)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 34, 14)) +>T : Symbol(T, Decl(assignAnyToEveryType.ts, 34, 11)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +module M { +>M : Symbol(M, Decl(assignAnyToEveryType.ts, 34, 34)) + + export var foo = 1; +>foo : Symbol(foo, Decl(assignAnyToEveryType.ts, 37, 14)) +} + +M = x; +>M : Symbol(M, Decl(assignAnyToEveryType.ts, 34, 34)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) + +function k(a: T) { +>k : Symbol(k, Decl(assignAnyToEveryType.ts, 40, 6)) +>T : Symbol(T, Decl(assignAnyToEveryType.ts, 42, 11)) +>a : Symbol(a, Decl(assignAnyToEveryType.ts, 42, 14)) +>T : Symbol(T, Decl(assignAnyToEveryType.ts, 42, 11)) + + a = x; +>a : Symbol(a, Decl(assignAnyToEveryType.ts, 42, 14)) +>x : Symbol(x, Decl(assignAnyToEveryType.ts, 2, 3)) +} diff --git a/tests/baselines/reference/assignAnyToEveryType.types b/tests/baselines/reference/assignAnyToEveryType.types new file mode 100644 index 00000000000..c3f475d058d --- /dev/null +++ b/tests/baselines/reference/assignAnyToEveryType.types @@ -0,0 +1,122 @@ +=== tests/cases/conformance/types/any/assignAnyToEveryType.ts === +// all of these are valid + +var x: any; +>x : any + +var a: number = x; +>a : number +>x : any + +var b: boolean = x; +>b : boolean +>x : any + +var c: string = x; +>c : string +>x : any + +var d: void = x; +>d : void +>x : any + +var e = null; +>e : any +>null : null + +e = x; +>e = x : any +>e : any +>x : any + +var f = undefined; +>f : any +>undefined : undefined + +f = x; +>f = x : any +>f : any +>x : any + +enum E { +>E : E + + A +>A : E +} + +var g: E = x; +>g : E +>E : E +>x : any + +var g2 = E.A; +>g2 : E +>E.A : E +>E : typeof E +>A : E + +g2 = x; +>g2 = x : any +>g2 : E +>x : any + +class C { +>C : C + + foo: string; +>foo : string +} + +var h: C = x; +>h : C +>C : C +>x : any + +interface I { +>I : I + + foo: string; +>foo : string +} + +var i: I = x; +>i : I +>I : I +>x : any + +var j: { (): string } = x; +>j : () => string +>x : any + +var j2: { (x: T): string } = x; +>j2 : (x: T) => string +>T : T +>x : T +>T : T +>x : any + +module M { +>M : typeof M + + export var foo = 1; +>foo : number +>1 : 1 +} + +M = x; +>M = x : any +>M : any +>x : any + +function k(a: T) { +>k : (a: T) => void +>T : T +>a : T +>T : T + + a = x; +>a = x : any +>a : T +>x : any +} diff --git a/tests/baselines/reference/assignFromBooleanInterface.symbols b/tests/baselines/reference/assignFromBooleanInterface.symbols new file mode 100644 index 00000000000..a9f747cab0b --- /dev/null +++ b/tests/baselines/reference/assignFromBooleanInterface.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts === +var x = true; +>x : Symbol(x, Decl(assignFromBooleanInterface.ts, 0, 3)) + +var a: Boolean; +>a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 3)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +x = a; +>x : Symbol(x, Decl(assignFromBooleanInterface.ts, 0, 3)) +>a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 3)) + +a = x; +>a : Symbol(a, Decl(assignFromBooleanInterface.ts, 1, 3)) +>x : Symbol(x, Decl(assignFromBooleanInterface.ts, 0, 3)) + diff --git a/tests/baselines/reference/assignFromBooleanInterface.types b/tests/baselines/reference/assignFromBooleanInterface.types new file mode 100644 index 00000000000..598f89bc2a4 --- /dev/null +++ b/tests/baselines/reference/assignFromBooleanInterface.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts === +var x = true; +>x : boolean +>true : true + +var a: Boolean; +>a : Boolean +>Boolean : Boolean + +x = a; +>x = a : Boolean +>x : boolean +>a : Boolean + +a = x; +>a = x : boolean +>a : Boolean +>x : boolean + diff --git a/tests/baselines/reference/assignFromBooleanInterface2.symbols b/tests/baselines/reference/assignFromBooleanInterface2.symbols new file mode 100644 index 00000000000..2bc7c3cf289 --- /dev/null +++ b/tests/baselines/reference/assignFromBooleanInterface2.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts === +interface Boolean { +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(assignFromBooleanInterface2.ts, 0, 0)) + + doStuff(): string; +>doStuff : Symbol(Boolean.doStuff, Decl(assignFromBooleanInterface2.ts, 0, 19)) +} + +interface NotBoolean { +>NotBoolean : Symbol(NotBoolean, Decl(assignFromBooleanInterface2.ts, 2, 1)) + + doStuff(): string; +>doStuff : Symbol(NotBoolean.doStuff, Decl(assignFromBooleanInterface2.ts, 4, 22)) +} + +var x = true; +>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3)) + +var a: Boolean; +>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(assignFromBooleanInterface2.ts, 0, 0)) + +var b: NotBoolean; +>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3)) +>NotBoolean : Symbol(NotBoolean, Decl(assignFromBooleanInterface2.ts, 2, 1)) + +a = x; +>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3)) +>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3)) + +a = b; +>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3)) +>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3)) + +b = a; +>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3)) +>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3)) + +b = x; +>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3)) +>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3)) + +x = a; // expected error +>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3)) +>a : Symbol(a, Decl(assignFromBooleanInterface2.ts, 9, 3)) + +x = b; // expected error +>x : Symbol(x, Decl(assignFromBooleanInterface2.ts, 8, 3)) +>b : Symbol(b, Decl(assignFromBooleanInterface2.ts, 10, 3)) + + diff --git a/tests/baselines/reference/assignFromBooleanInterface2.types b/tests/baselines/reference/assignFromBooleanInterface2.types new file mode 100644 index 00000000000..7472fec421a --- /dev/null +++ b/tests/baselines/reference/assignFromBooleanInterface2.types @@ -0,0 +1,58 @@ +=== tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts === +interface Boolean { +>Boolean : Boolean + + doStuff(): string; +>doStuff : () => string +} + +interface NotBoolean { +>NotBoolean : NotBoolean + + doStuff(): string; +>doStuff : () => string +} + +var x = true; +>x : boolean +>true : true + +var a: Boolean; +>a : Boolean +>Boolean : Boolean + +var b: NotBoolean; +>b : NotBoolean +>NotBoolean : NotBoolean + +a = x; +>a = x : true +>a : Boolean +>x : true + +a = b; +>a = b : NotBoolean +>a : Boolean +>b : NotBoolean + +b = a; +>b = a : Boolean +>b : NotBoolean +>a : Boolean + +b = x; +>b = x : true +>b : NotBoolean +>x : true + +x = a; // expected error +>x = a : Boolean +>x : boolean +>a : Boolean + +x = b; // expected error +>x = b : NotBoolean +>x : boolean +>b : NotBoolean + + diff --git a/tests/baselines/reference/assignFromNumberInterface.symbols b/tests/baselines/reference/assignFromNumberInterface.symbols new file mode 100644 index 00000000000..06485958aab --- /dev/null +++ b/tests/baselines/reference/assignFromNumberInterface.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts === +var x = 1; +>x : Symbol(x, Decl(assignFromNumberInterface.ts, 0, 3)) + +var a: Number; +>a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +x = a; +>x : Symbol(x, Decl(assignFromNumberInterface.ts, 0, 3)) +>a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 3)) + +a = x; +>a : Symbol(a, Decl(assignFromNumberInterface.ts, 1, 3)) +>x : Symbol(x, Decl(assignFromNumberInterface.ts, 0, 3)) + diff --git a/tests/baselines/reference/assignFromNumberInterface.types b/tests/baselines/reference/assignFromNumberInterface.types new file mode 100644 index 00000000000..d37023d8a53 --- /dev/null +++ b/tests/baselines/reference/assignFromNumberInterface.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts === +var x = 1; +>x : number +>1 : 1 + +var a: Number; +>a : Number +>Number : Number + +x = a; +>x = a : Number +>x : number +>a : Number + +a = x; +>a = x : number +>a : Number +>x : number + diff --git a/tests/baselines/reference/assignFromNumberInterface2.symbols b/tests/baselines/reference/assignFromNumberInterface2.symbols new file mode 100644 index 00000000000..45bc0762b30 --- /dev/null +++ b/tests/baselines/reference/assignFromNumberInterface2.symbols @@ -0,0 +1,70 @@ +=== tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts === +interface Number { +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(assignFromNumberInterface2.ts, 0, 0)) + + doStuff(): string; +>doStuff : Symbol(Number.doStuff, Decl(assignFromNumberInterface2.ts, 0, 18)) +} + +interface NotNumber { +>NotNumber : Symbol(NotNumber, Decl(assignFromNumberInterface2.ts, 2, 1)) + + toString(radix?: number): string; +>toString : Symbol(NotNumber.toString, Decl(assignFromNumberInterface2.ts, 4, 21)) +>radix : Symbol(radix, Decl(assignFromNumberInterface2.ts, 5, 13)) + + toFixed(fractionDigits?: number): string; +>toFixed : Symbol(NotNumber.toFixed, Decl(assignFromNumberInterface2.ts, 5, 37)) +>fractionDigits : Symbol(fractionDigits, Decl(assignFromNumberInterface2.ts, 6, 12)) + + toExponential(fractionDigits?: number): string; +>toExponential : Symbol(NotNumber.toExponential, Decl(assignFromNumberInterface2.ts, 6, 45)) +>fractionDigits : Symbol(fractionDigits, Decl(assignFromNumberInterface2.ts, 7, 18)) + + toPrecision(precision?: number): string; +>toPrecision : Symbol(NotNumber.toPrecision, Decl(assignFromNumberInterface2.ts, 7, 51)) +>precision : Symbol(precision, Decl(assignFromNumberInterface2.ts, 8, 16)) + + valueOf(): number; +>valueOf : Symbol(NotNumber.valueOf, Decl(assignFromNumberInterface2.ts, 8, 44)) + + doStuff(): string; +>doStuff : Symbol(NotNumber.doStuff, Decl(assignFromNumberInterface2.ts, 9, 22)) +} + +var x = 1; +>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3)) + +var a: Number; +>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(assignFromNumberInterface2.ts, 0, 0)) + +var b: NotNumber; +>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3)) +>NotNumber : Symbol(NotNumber, Decl(assignFromNumberInterface2.ts, 2, 1)) + +a = x; +>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3)) +>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3)) + +a = b; +>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3)) +>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3)) + +b = a; +>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3)) +>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3)) + +b = x; +>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3)) +>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3)) + +x = a; // expected error +>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3)) +>a : Symbol(a, Decl(assignFromNumberInterface2.ts, 14, 3)) + +x = b; // expected error +>x : Symbol(x, Decl(assignFromNumberInterface2.ts, 13, 3)) +>b : Symbol(b, Decl(assignFromNumberInterface2.ts, 15, 3)) + + diff --git a/tests/baselines/reference/assignFromNumberInterface2.types b/tests/baselines/reference/assignFromNumberInterface2.types new file mode 100644 index 00000000000..d2c4fc04658 --- /dev/null +++ b/tests/baselines/reference/assignFromNumberInterface2.types @@ -0,0 +1,77 @@ +=== tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts === +interface Number { +>Number : Number + + doStuff(): string; +>doStuff : () => string +} + +interface NotNumber { +>NotNumber : NotNumber + + toString(radix?: number): string; +>toString : (radix?: number) => string +>radix : number + + toFixed(fractionDigits?: number): string; +>toFixed : (fractionDigits?: number) => string +>fractionDigits : number + + toExponential(fractionDigits?: number): string; +>toExponential : (fractionDigits?: number) => string +>fractionDigits : number + + toPrecision(precision?: number): string; +>toPrecision : (precision?: number) => string +>precision : number + + valueOf(): number; +>valueOf : () => number + + doStuff(): string; +>doStuff : () => string +} + +var x = 1; +>x : number +>1 : 1 + +var a: Number; +>a : Number +>Number : Number + +var b: NotNumber; +>b : NotNumber +>NotNumber : NotNumber + +a = x; +>a = x : number +>a : Number +>x : number + +a = b; +>a = b : NotNumber +>a : Number +>b : NotNumber + +b = a; +>b = a : Number +>b : NotNumber +>a : Number + +b = x; +>b = x : number +>b : NotNumber +>x : number + +x = a; // expected error +>x = a : Number +>x : number +>a : Number + +x = b; // expected error +>x = b : NotNumber +>x : number +>b : NotNumber + + diff --git a/tests/baselines/reference/assignFromStringInterface.symbols b/tests/baselines/reference/assignFromStringInterface.symbols new file mode 100644 index 00000000000..348c237ca1f --- /dev/null +++ b/tests/baselines/reference/assignFromStringInterface.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts === +var x = ''; +>x : Symbol(x, Decl(assignFromStringInterface.ts, 0, 3)) + +var a: String; +>a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 3)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +x = a; +>x : Symbol(x, Decl(assignFromStringInterface.ts, 0, 3)) +>a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 3)) + +a = x; +>a : Symbol(a, Decl(assignFromStringInterface.ts, 1, 3)) +>x : Symbol(x, Decl(assignFromStringInterface.ts, 0, 3)) + diff --git a/tests/baselines/reference/assignFromStringInterface.types b/tests/baselines/reference/assignFromStringInterface.types new file mode 100644 index 00000000000..07c2433e586 --- /dev/null +++ b/tests/baselines/reference/assignFromStringInterface.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts === +var x = ''; +>x : string +>'' : "" + +var a: String; +>a : String +>String : String + +x = a; +>x = a : String +>x : string +>a : String + +a = x; +>a = x : string +>a : String +>x : string + diff --git a/tests/baselines/reference/assignFromStringInterface2.symbols b/tests/baselines/reference/assignFromStringInterface2.symbols new file mode 100644 index 00000000000..88fd673c708 --- /dev/null +++ b/tests/baselines/reference/assignFromStringInterface2.symbols @@ -0,0 +1,174 @@ +=== tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts === +interface String { +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(assignFromStringInterface2.ts, 0, 0)) + + doStuff(): string; +>doStuff : Symbol(String.doStuff, Decl(assignFromStringInterface2.ts, 0, 18)) +} + +interface NotString { +>NotString : Symbol(NotString, Decl(assignFromStringInterface2.ts, 2, 1)) + + doStuff(): string; +>doStuff : Symbol(NotString.doStuff, Decl(assignFromStringInterface2.ts, 4, 21)) + + toString(): string; +>toString : Symbol(NotString.toString, Decl(assignFromStringInterface2.ts, 5, 22)) + + charAt(pos: number): string; +>charAt : Symbol(NotString.charAt, Decl(assignFromStringInterface2.ts, 6, 23)) +>pos : Symbol(pos, Decl(assignFromStringInterface2.ts, 7, 11)) + + charCodeAt(index: number): number; +>charCodeAt : Symbol(NotString.charCodeAt, Decl(assignFromStringInterface2.ts, 7, 32)) +>index : Symbol(index, Decl(assignFromStringInterface2.ts, 8, 15)) + + concat(...strings: string[]): string; +>concat : Symbol(NotString.concat, Decl(assignFromStringInterface2.ts, 8, 38)) +>strings : Symbol(strings, Decl(assignFromStringInterface2.ts, 9, 11)) + + indexOf(searchString: string, position?: number): number; +>indexOf : Symbol(NotString.indexOf, Decl(assignFromStringInterface2.ts, 9, 41)) +>searchString : Symbol(searchString, Decl(assignFromStringInterface2.ts, 10, 12)) +>position : Symbol(position, Decl(assignFromStringInterface2.ts, 10, 33)) + + lastIndexOf(searchString: string, position?: number): number; +>lastIndexOf : Symbol(NotString.lastIndexOf, Decl(assignFromStringInterface2.ts, 10, 61)) +>searchString : Symbol(searchString, Decl(assignFromStringInterface2.ts, 11, 16)) +>position : Symbol(position, Decl(assignFromStringInterface2.ts, 11, 37)) + + localeCompare(that: string): number; +>localeCompare : Symbol(NotString.localeCompare, Decl(assignFromStringInterface2.ts, 11, 65)) +>that : Symbol(that, Decl(assignFromStringInterface2.ts, 12, 18)) + + match(regexp: string): string[]; +>match : Symbol(NotString.match, Decl(assignFromStringInterface2.ts, 12, 40), Decl(assignFromStringInterface2.ts, 13, 36)) +>regexp : Symbol(regexp, Decl(assignFromStringInterface2.ts, 13, 10)) + + match(regexp: RegExp): string[]; +>match : Symbol(NotString.match, Decl(assignFromStringInterface2.ts, 12, 40), Decl(assignFromStringInterface2.ts, 13, 36)) +>regexp : Symbol(regexp, Decl(assignFromStringInterface2.ts, 14, 10)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + replace(searchValue: string, replaceValue: string): string; +>replace : Symbol(NotString.replace, Decl(assignFromStringInterface2.ts, 14, 36), Decl(assignFromStringInterface2.ts, 15, 63), Decl(assignFromStringInterface2.ts, 16, 102), Decl(assignFromStringInterface2.ts, 17, 63)) +>searchValue : Symbol(searchValue, Decl(assignFromStringInterface2.ts, 15, 12)) +>replaceValue : Symbol(replaceValue, Decl(assignFromStringInterface2.ts, 15, 32)) + + replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; +>replace : Symbol(NotString.replace, Decl(assignFromStringInterface2.ts, 14, 36), Decl(assignFromStringInterface2.ts, 15, 63), Decl(assignFromStringInterface2.ts, 16, 102), Decl(assignFromStringInterface2.ts, 17, 63)) +>searchValue : Symbol(searchValue, Decl(assignFromStringInterface2.ts, 16, 12)) +>replaceValue : Symbol(replaceValue, Decl(assignFromStringInterface2.ts, 16, 32)) +>substring : Symbol(substring, Decl(assignFromStringInterface2.ts, 16, 48)) +>args : Symbol(args, Decl(assignFromStringInterface2.ts, 16, 66)) + + replace(searchValue: RegExp, replaceValue: string): string; +>replace : Symbol(NotString.replace, Decl(assignFromStringInterface2.ts, 14, 36), Decl(assignFromStringInterface2.ts, 15, 63), Decl(assignFromStringInterface2.ts, 16, 102), Decl(assignFromStringInterface2.ts, 17, 63)) +>searchValue : Symbol(searchValue, Decl(assignFromStringInterface2.ts, 17, 12)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>replaceValue : Symbol(replaceValue, Decl(assignFromStringInterface2.ts, 17, 32)) + + replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; +>replace : Symbol(NotString.replace, Decl(assignFromStringInterface2.ts, 14, 36), Decl(assignFromStringInterface2.ts, 15, 63), Decl(assignFromStringInterface2.ts, 16, 102), Decl(assignFromStringInterface2.ts, 17, 63)) +>searchValue : Symbol(searchValue, Decl(assignFromStringInterface2.ts, 18, 12)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>replaceValue : Symbol(replaceValue, Decl(assignFromStringInterface2.ts, 18, 32)) +>substring : Symbol(substring, Decl(assignFromStringInterface2.ts, 18, 48)) +>args : Symbol(args, Decl(assignFromStringInterface2.ts, 18, 66)) + + search(regexp: string): number; +>search : Symbol(NotString.search, Decl(assignFromStringInterface2.ts, 18, 102), Decl(assignFromStringInterface2.ts, 19, 35)) +>regexp : Symbol(regexp, Decl(assignFromStringInterface2.ts, 19, 11)) + + search(regexp: RegExp): number; +>search : Symbol(NotString.search, Decl(assignFromStringInterface2.ts, 18, 102), Decl(assignFromStringInterface2.ts, 19, 35)) +>regexp : Symbol(regexp, Decl(assignFromStringInterface2.ts, 20, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + slice(start?: number, end?: number): string; +>slice : Symbol(NotString.slice, Decl(assignFromStringInterface2.ts, 20, 35)) +>start : Symbol(start, Decl(assignFromStringInterface2.ts, 21, 10)) +>end : Symbol(end, Decl(assignFromStringInterface2.ts, 21, 25)) + + split(separator: string, limit?: number): string[]; +>split : Symbol(NotString.split, Decl(assignFromStringInterface2.ts, 21, 48), Decl(assignFromStringInterface2.ts, 22, 55)) +>separator : Symbol(separator, Decl(assignFromStringInterface2.ts, 22, 10)) +>limit : Symbol(limit, Decl(assignFromStringInterface2.ts, 22, 28)) + + split(separator: RegExp, limit?: number): string[]; +>split : Symbol(NotString.split, Decl(assignFromStringInterface2.ts, 21, 48), Decl(assignFromStringInterface2.ts, 22, 55)) +>separator : Symbol(separator, Decl(assignFromStringInterface2.ts, 23, 10)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>limit : Symbol(limit, Decl(assignFromStringInterface2.ts, 23, 28)) + + substring(start: number, end?: number): string; +>substring : Symbol(NotString.substring, Decl(assignFromStringInterface2.ts, 23, 55)) +>start : Symbol(start, Decl(assignFromStringInterface2.ts, 24, 14)) +>end : Symbol(end, Decl(assignFromStringInterface2.ts, 24, 28)) + + toLowerCase(): string; +>toLowerCase : Symbol(NotString.toLowerCase, Decl(assignFromStringInterface2.ts, 24, 51)) + + toLocaleLowerCase(): string; +>toLocaleLowerCase : Symbol(NotString.toLocaleLowerCase, Decl(assignFromStringInterface2.ts, 25, 26)) + + toUpperCase(): string; +>toUpperCase : Symbol(NotString.toUpperCase, Decl(assignFromStringInterface2.ts, 26, 32)) + + toLocaleUpperCase(): string; +>toLocaleUpperCase : Symbol(NotString.toLocaleUpperCase, Decl(assignFromStringInterface2.ts, 27, 26)) + + trim(): string; +>trim : Symbol(NotString.trim, Decl(assignFromStringInterface2.ts, 28, 32)) + + length: number; +>length : Symbol(NotString.length, Decl(assignFromStringInterface2.ts, 29, 19)) + + substr(from: number, length?: number): string; +>substr : Symbol(NotString.substr, Decl(assignFromStringInterface2.ts, 30, 19)) +>from : Symbol(from, Decl(assignFromStringInterface2.ts, 31, 11)) +>length : Symbol(length, Decl(assignFromStringInterface2.ts, 31, 24)) + + valueOf(): string; +>valueOf : Symbol(NotString.valueOf, Decl(assignFromStringInterface2.ts, 31, 50)) + + [index: number]: string; +>index : Symbol(index, Decl(assignFromStringInterface2.ts, 33, 5)) +} + +var x = ''; +>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3)) + +var a: String; +>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(assignFromStringInterface2.ts, 0, 0)) + +var b: NotString; +>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3)) +>NotString : Symbol(NotString, Decl(assignFromStringInterface2.ts, 2, 1)) + +a = x; +>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3)) +>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3)) + +a = b; +>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3)) +>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3)) + +b = a; +>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3)) +>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3)) + +b = x; +>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3)) +>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3)) + +x = a; // expected error +>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3)) +>a : Symbol(a, Decl(assignFromStringInterface2.ts, 37, 3)) + +x = b; // expected error +>x : Symbol(x, Decl(assignFromStringInterface2.ts, 36, 3)) +>b : Symbol(b, Decl(assignFromStringInterface2.ts, 38, 3)) + + diff --git a/tests/baselines/reference/assignFromStringInterface2.types b/tests/baselines/reference/assignFromStringInterface2.types new file mode 100644 index 00000000000..8ec212babce --- /dev/null +++ b/tests/baselines/reference/assignFromStringInterface2.types @@ -0,0 +1,181 @@ +=== tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts === +interface String { +>String : String + + doStuff(): string; +>doStuff : () => string +} + +interface NotString { +>NotString : NotString + + doStuff(): string; +>doStuff : () => string + + toString(): string; +>toString : () => string + + charAt(pos: number): string; +>charAt : (pos: number) => string +>pos : number + + charCodeAt(index: number): number; +>charCodeAt : (index: number) => number +>index : number + + concat(...strings: string[]): string; +>concat : (...strings: string[]) => string +>strings : string[] + + indexOf(searchString: string, position?: number): number; +>indexOf : (searchString: string, position?: number) => number +>searchString : string +>position : number + + lastIndexOf(searchString: string, position?: number): number; +>lastIndexOf : (searchString: string, position?: number) => number +>searchString : string +>position : number + + localeCompare(that: string): number; +>localeCompare : (that: string) => number +>that : string + + match(regexp: string): string[]; +>match : { (regexp: string): string[]; (regexp: RegExp): string[]; } +>regexp : string + + match(regexp: RegExp): string[]; +>match : { (regexp: string): string[]; (regexp: RegExp): string[]; } +>regexp : RegExp +>RegExp : RegExp + + replace(searchValue: string, replaceValue: string): string; +>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; } +>searchValue : string +>replaceValue : string + + replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; +>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; } +>searchValue : string +>replaceValue : (substring: string, ...args: any[]) => string +>substring : string +>args : any[] + + replace(searchValue: RegExp, replaceValue: string): string; +>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; } +>searchValue : RegExp +>RegExp : RegExp +>replaceValue : string + + replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; +>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; } +>searchValue : RegExp +>RegExp : RegExp +>replaceValue : (substring: string, ...args: any[]) => string +>substring : string +>args : any[] + + search(regexp: string): number; +>search : { (regexp: string): number; (regexp: RegExp): number; } +>regexp : string + + search(regexp: RegExp): number; +>search : { (regexp: string): number; (regexp: RegExp): number; } +>regexp : RegExp +>RegExp : RegExp + + slice(start?: number, end?: number): string; +>slice : (start?: number, end?: number) => string +>start : number +>end : number + + split(separator: string, limit?: number): string[]; +>split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; } +>separator : string +>limit : number + + split(separator: RegExp, limit?: number): string[]; +>split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; } +>separator : RegExp +>RegExp : RegExp +>limit : number + + substring(start: number, end?: number): string; +>substring : (start: number, end?: number) => string +>start : number +>end : number + + toLowerCase(): string; +>toLowerCase : () => string + + toLocaleLowerCase(): string; +>toLocaleLowerCase : () => string + + toUpperCase(): string; +>toUpperCase : () => string + + toLocaleUpperCase(): string; +>toLocaleUpperCase : () => string + + trim(): string; +>trim : () => string + + length: number; +>length : number + + substr(from: number, length?: number): string; +>substr : (from: number, length?: number) => string +>from : number +>length : number + + valueOf(): string; +>valueOf : () => string + + [index: number]: string; +>index : number +} + +var x = ''; +>x : string +>'' : "" + +var a: String; +>a : String +>String : String + +var b: NotString; +>b : NotString +>NotString : NotString + +a = x; +>a = x : string +>a : String +>x : string + +a = b; +>a = b : NotString +>a : String +>b : NotString + +b = a; +>b = a : String +>b : NotString +>a : String + +b = x; +>b = x : string +>b : NotString +>x : string + +x = a; // expected error +>x = a : String +>x : string +>a : String + +x = b; // expected error +>x = b : NotString +>x : string +>b : NotString + + diff --git a/tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.symbols b/tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.symbols new file mode 100644 index 00000000000..19dac44b30c --- /dev/null +++ b/tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.symbols @@ -0,0 +1,24 @@ +=== tests/cases/compiler/assignLambdaToNominalSubtypeOfFunction.ts === +interface IResultCallback extends Function { +>IResultCallback : Symbol(IResultCallback, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 0, 0)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + x: number; +>x : Symbol(IResultCallback.x, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 0, 44)) +} + +function fn(cb: IResultCallback) { } +>fn : Symbol(fn, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 2, 1)) +>cb : Symbol(cb, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 4, 12)) +>IResultCallback : Symbol(IResultCallback, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 0, 0)) + +fn((a, b) => true); +>fn : Symbol(fn, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 2, 1)) +>a : Symbol(a, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 6, 4)) +>b : Symbol(b, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 6, 6)) + +fn(function (a, b) { return true; }) +>fn : Symbol(fn, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 2, 1)) +>a : Symbol(a, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 7, 13)) +>b : Symbol(b, Decl(assignLambdaToNominalSubtypeOfFunction.ts, 7, 15)) + diff --git a/tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.types b/tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.types new file mode 100644 index 00000000000..bff7fe98da4 --- /dev/null +++ b/tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.types @@ -0,0 +1,30 @@ +=== tests/cases/compiler/assignLambdaToNominalSubtypeOfFunction.ts === +interface IResultCallback extends Function { +>IResultCallback : IResultCallback +>Function : Function + + x: number; +>x : number +} + +function fn(cb: IResultCallback) { } +>fn : (cb: IResultCallback) => void +>cb : IResultCallback +>IResultCallback : IResultCallback + +fn((a, b) => true); +>fn((a, b) => true) : void +>fn : (cb: IResultCallback) => void +>(a, b) => true : (a: any, b: any) => boolean +>a : any +>b : any +>true : true + +fn(function (a, b) { return true; }) +>fn(function (a, b) { return true; }) : void +>fn : (cb: IResultCallback) => void +>function (a, b) { return true; } : (a: any, b: any) => boolean +>a : any +>b : any +>true : true + diff --git a/tests/baselines/reference/assignToEnum.symbols b/tests/baselines/reference/assignToEnum.symbols new file mode 100644 index 00000000000..8abccb32ce4 --- /dev/null +++ b/tests/baselines/reference/assignToEnum.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/assignToEnum.ts === +enum A { foo, bar } +>A : Symbol(A, Decl(assignToEnum.ts, 0, 0)) +>foo : Symbol(A.foo, Decl(assignToEnum.ts, 0, 8)) +>bar : Symbol(A.bar, Decl(assignToEnum.ts, 0, 13)) + +A = undefined; // invalid LHS +>A : Symbol(A, Decl(assignToEnum.ts, 0, 0)) +>undefined : Symbol(undefined) + +A = A.bar; // invalid LHS +>A : Symbol(A, Decl(assignToEnum.ts, 0, 0)) +>A.bar : Symbol(A.bar, Decl(assignToEnum.ts, 0, 13)) +>A : Symbol(A, Decl(assignToEnum.ts, 0, 0)) +>bar : Symbol(A.bar, Decl(assignToEnum.ts, 0, 13)) + +A.foo = 1; // invalid LHS +>A.foo : Symbol(A.foo, Decl(assignToEnum.ts, 0, 8)) +>A : Symbol(A, Decl(assignToEnum.ts, 0, 0)) +>foo : Symbol(A.foo, Decl(assignToEnum.ts, 0, 8)) + +A.foo = A.bar; // invalid LHS +>A.foo : Symbol(A.foo, Decl(assignToEnum.ts, 0, 8)) +>A : Symbol(A, Decl(assignToEnum.ts, 0, 0)) +>foo : Symbol(A.foo, Decl(assignToEnum.ts, 0, 8)) +>A.bar : Symbol(A.bar, Decl(assignToEnum.ts, 0, 13)) +>A : Symbol(A, Decl(assignToEnum.ts, 0, 0)) +>bar : Symbol(A.bar, Decl(assignToEnum.ts, 0, 13)) + + diff --git a/tests/baselines/reference/assignToEnum.types b/tests/baselines/reference/assignToEnum.types new file mode 100644 index 00000000000..a4301d113ab --- /dev/null +++ b/tests/baselines/reference/assignToEnum.types @@ -0,0 +1,35 @@ +=== tests/cases/compiler/assignToEnum.ts === +enum A { foo, bar } +>A : A +>foo : A.foo +>bar : A.bar + +A = undefined; // invalid LHS +>A = undefined : undefined +>A : any +>undefined : undefined + +A = A.bar; // invalid LHS +>A = A.bar : A.bar +>A : any +>A.bar : A.bar +>A : typeof A +>bar : A.bar + +A.foo = 1; // invalid LHS +>A.foo = 1 : 1 +>A.foo : any +>A : typeof A +>foo : any +>1 : 1 + +A.foo = A.bar; // invalid LHS +>A.foo = A.bar : A.bar +>A.foo : any +>A : typeof A +>foo : any +>A.bar : A.bar +>A : typeof A +>bar : A.bar + + diff --git a/tests/baselines/reference/assignToExistingClass.symbols b/tests/baselines/reference/assignToExistingClass.symbols new file mode 100644 index 00000000000..9d170e9e30c --- /dev/null +++ b/tests/baselines/reference/assignToExistingClass.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/assignToExistingClass.ts === +module Test { +>Test : Symbol(Test, Decl(assignToExistingClass.ts, 0, 0)) + + class Mocked { +>Mocked : Symbol(Mocked, Decl(assignToExistingClass.ts, 0, 13)) + + myProp: string; +>myProp : Symbol(Mocked.myProp, Decl(assignToExistingClass.ts, 1, 18)) + } + + class Tester { +>Tester : Symbol(Tester, Decl(assignToExistingClass.ts, 3, 5)) + + willThrowError() { +>willThrowError : Symbol(Tester.willThrowError, Decl(assignToExistingClass.ts, 5, 18)) + + Mocked = Mocked || function () { // => Error: Invalid left-hand side of assignment expression. +>Mocked : Symbol(Mocked, Decl(assignToExistingClass.ts, 0, 13)) +>Mocked : Symbol(Mocked, Decl(assignToExistingClass.ts, 0, 13)) + + return { myProp: "test" }; +>myProp : Symbol(myProp, Decl(assignToExistingClass.ts, 8, 24)) + + }; + } + } + +} + diff --git a/tests/baselines/reference/assignToExistingClass.types b/tests/baselines/reference/assignToExistingClass.types new file mode 100644 index 00000000000..9894347c20f --- /dev/null +++ b/tests/baselines/reference/assignToExistingClass.types @@ -0,0 +1,35 @@ +=== tests/cases/compiler/assignToExistingClass.ts === +module Test { +>Test : typeof Test + + class Mocked { +>Mocked : Mocked + + myProp: string; +>myProp : string + } + + class Tester { +>Tester : Tester + + willThrowError() { +>willThrowError : () => void + + Mocked = Mocked || function () { // => Error: Invalid left-hand side of assignment expression. +>Mocked = Mocked || function () { // => Error: Invalid left-hand side of assignment expression. return { myProp: "test" }; } : typeof Mocked | (() => { myProp: string; }) +>Mocked : any +>Mocked || function () { // => Error: Invalid left-hand side of assignment expression. return { myProp: "test" }; } : typeof Mocked | (() => { myProp: string; }) +>Mocked : typeof Mocked +>function () { // => Error: Invalid left-hand side of assignment expression. return { myProp: "test" }; } : () => { myProp: string; } + + return { myProp: "test" }; +>{ myProp: "test" } : { myProp: string; } +>myProp : string +>"test" : "test" + + }; + } + } + +} + diff --git a/tests/baselines/reference/assignToFn.symbols b/tests/baselines/reference/assignToFn.symbols new file mode 100644 index 00000000000..497515eec99 --- /dev/null +++ b/tests/baselines/reference/assignToFn.symbols @@ -0,0 +1,24 @@ +=== tests/cases/compiler/assignToFn.ts === +module M { +>M : Symbol(M, Decl(assignToFn.ts, 0, 0)) + + interface I { +>I : Symbol(I, Decl(assignToFn.ts, 0, 10)) + + f(n:number):boolean; +>f : Symbol(I.f, Decl(assignToFn.ts, 1, 17)) +>n : Symbol(n, Decl(assignToFn.ts, 2, 3)) + } + + var x:I={ f:function(n) { return true; } }; +>x : Symbol(x, Decl(assignToFn.ts, 5, 7)) +>I : Symbol(I, Decl(assignToFn.ts, 0, 10)) +>f : Symbol(f, Decl(assignToFn.ts, 5, 13)) +>n : Symbol(n, Decl(assignToFn.ts, 5, 25)) + + x.f="hello"; +>x.f : Symbol(I.f, Decl(assignToFn.ts, 1, 17)) +>x : Symbol(x, Decl(assignToFn.ts, 5, 7)) +>f : Symbol(I.f, Decl(assignToFn.ts, 1, 17)) +} + diff --git a/tests/baselines/reference/assignToFn.types b/tests/baselines/reference/assignToFn.types new file mode 100644 index 00000000000..927f2261fcf --- /dev/null +++ b/tests/baselines/reference/assignToFn.types @@ -0,0 +1,29 @@ +=== tests/cases/compiler/assignToFn.ts === +module M { +>M : typeof M + + interface I { +>I : I + + f(n:number):boolean; +>f : (n: number) => boolean +>n : number + } + + var x:I={ f:function(n) { return true; } }; +>x : I +>I : I +>{ f:function(n) { return true; } } : { f: (n: number) => true; } +>f : (n: number) => true +>function(n) { return true; } : (n: number) => true +>n : number +>true : true + + x.f="hello"; +>x.f="hello" : "hello" +>x.f : (n: number) => boolean +>x : I +>f : (n: number) => boolean +>"hello" : "hello" +} + diff --git a/tests/baselines/reference/assignToInvalidLHS.symbols b/tests/baselines/reference/assignToInvalidLHS.symbols new file mode 100644 index 00000000000..3a1cd4974b0 --- /dev/null +++ b/tests/baselines/reference/assignToInvalidLHS.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/assignToInvalidLHS.ts === +declare var y:any; +>y : Symbol(y, Decl(assignToInvalidLHS.ts, 0, 11)) + +// Below is actually valid JavaScript (see http://es5.github.com/#x8.7 ), even though will always fail at runtime with 'invalid left-hand side' +var x = new y = 5; +>x : Symbol(x, Decl(assignToInvalidLHS.ts, 3, 3)) +>y : Symbol(y, Decl(assignToInvalidLHS.ts, 0, 11)) + diff --git a/tests/baselines/reference/assignToInvalidLHS.types b/tests/baselines/reference/assignToInvalidLHS.types new file mode 100644 index 00000000000..7a24245010c --- /dev/null +++ b/tests/baselines/reference/assignToInvalidLHS.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/assignToInvalidLHS.ts === +declare var y:any; +>y : any + +// Below is actually valid JavaScript (see http://es5.github.com/#x8.7 ), even though will always fail at runtime with 'invalid left-hand side' +var x = new y = 5; +>x : number +>new y = 5 : 5 +>new y : any +>y : any +>5 : 5 + diff --git a/tests/baselines/reference/assignToModule.symbols b/tests/baselines/reference/assignToModule.symbols new file mode 100644 index 00000000000..9461056de11 --- /dev/null +++ b/tests/baselines/reference/assignToModule.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/assignToModule.ts === +module A {} +>A : Symbol(A, Decl(assignToModule.ts, 0, 0)) + +A = undefined; // invalid LHS +>undefined : Symbol(undefined) + diff --git a/tests/baselines/reference/assignToModule.types b/tests/baselines/reference/assignToModule.types new file mode 100644 index 00000000000..887e3d2c2b1 --- /dev/null +++ b/tests/baselines/reference/assignToModule.types @@ -0,0 +1,9 @@ +=== tests/cases/compiler/assignToModule.ts === +module A {} +>A : any + +A = undefined; // invalid LHS +>A = undefined : undefined +>A : any +>undefined : undefined + diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.symbols b/tests/baselines/reference/assigningFromObjectToAnythingElse.symbols new file mode 100644 index 00000000000..ed085701932 --- /dev/null +++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.symbols @@ -0,0 +1,34 @@ +=== tests/cases/compiler/assigningFromObjectToAnythingElse.ts === +var x: Object; +>x : Symbol(x, Decl(assigningFromObjectToAnythingElse.ts, 0, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var y: RegExp; +>y : Symbol(y, Decl(assigningFromObjectToAnythingElse.ts, 1, 3)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +y = x; +>y : Symbol(y, Decl(assigningFromObjectToAnythingElse.ts, 1, 3)) +>x : Symbol(x, Decl(assigningFromObjectToAnythingElse.ts, 0, 3)) + +var a: String = Object.create(""); +>a : Symbol(a, Decl(assigningFromObjectToAnythingElse.ts, 4, 3)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var c: String = Object.create(1); +>c : Symbol(c, Decl(assigningFromObjectToAnythingElse.ts, 5, 3)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object.create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>create : Symbol(ObjectConstructor.create, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var w: Error = new Object(); +>w : Symbol(w, Decl(assigningFromObjectToAnythingElse.ts, 7, 3)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + diff --git a/tests/baselines/reference/assigningFromObjectToAnythingElse.types b/tests/baselines/reference/assigningFromObjectToAnythingElse.types new file mode 100644 index 00000000000..2b31b0c7673 --- /dev/null +++ b/tests/baselines/reference/assigningFromObjectToAnythingElse.types @@ -0,0 +1,40 @@ +=== tests/cases/compiler/assigningFromObjectToAnythingElse.ts === +var x: Object; +>x : Object +>Object : Object + +var y: RegExp; +>y : RegExp +>RegExp : RegExp + +y = x; +>y = x : Object +>y : RegExp +>x : Object + +var a: String = Object.create(""); +>a : String +>String : String +>Object.create("") : any +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType): any; } +>Object : ObjectConstructor +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType): any; } +>Object : Object +>"" : "" + +var c: String = Object.create(1); +>c : String +>String : String +>Object.create(1) : any +>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType): any; } +>Object : ObjectConstructor +>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType): any; } +>Number : Number +>1 : 1 + +var w: Error = new Object(); +>w : Error +>Error : Error +>new Object() : Object +>Object : ObjectConstructor + diff --git a/tests/baselines/reference/assignmentCompat1.symbols b/tests/baselines/reference/assignmentCompat1.symbols new file mode 100644 index 00000000000..43d4525e498 --- /dev/null +++ b/tests/baselines/reference/assignmentCompat1.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompat1.ts === +var x = { one: 1 }; +>x : Symbol(x, Decl(assignmentCompat1.ts, 0, 3)) +>one : Symbol(one, Decl(assignmentCompat1.ts, 0, 9)) + +var y: { [index: string]: any }; +>y : Symbol(y, Decl(assignmentCompat1.ts, 1, 3)) +>index : Symbol(index, Decl(assignmentCompat1.ts, 1, 10)) + +var z: { [index: number]: any }; +>z : Symbol(z, Decl(assignmentCompat1.ts, 2, 3)) +>index : Symbol(index, Decl(assignmentCompat1.ts, 2, 10)) + +x = y; // Error +>x : Symbol(x, Decl(assignmentCompat1.ts, 0, 3)) +>y : Symbol(y, Decl(assignmentCompat1.ts, 1, 3)) + +y = x; // Ok because index signature type is any +>y : Symbol(y, Decl(assignmentCompat1.ts, 1, 3)) +>x : Symbol(x, Decl(assignmentCompat1.ts, 0, 3)) + +x = z; // Error +>x : Symbol(x, Decl(assignmentCompat1.ts, 0, 3)) +>z : Symbol(z, Decl(assignmentCompat1.ts, 2, 3)) + +z = x; // Ok because index signature type is any +>z : Symbol(z, Decl(assignmentCompat1.ts, 2, 3)) +>x : Symbol(x, Decl(assignmentCompat1.ts, 0, 3)) + +y = "foo"; // Error +>y : Symbol(y, Decl(assignmentCompat1.ts, 1, 3)) + +z = "foo"; // OK, string has numeric indexer +>z : Symbol(z, Decl(assignmentCompat1.ts, 2, 3)) + +z = false; // Error +>z : Symbol(z, Decl(assignmentCompat1.ts, 2, 3)) + + diff --git a/tests/baselines/reference/assignmentCompat1.types b/tests/baselines/reference/assignmentCompat1.types new file mode 100644 index 00000000000..7036cca1725 --- /dev/null +++ b/tests/baselines/reference/assignmentCompat1.types @@ -0,0 +1,51 @@ +=== tests/cases/compiler/assignmentCompat1.ts === +var x = { one: 1 }; +>x : { one: number; } +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + +var y: { [index: string]: any }; +>y : { [index: string]: any; } +>index : string + +var z: { [index: number]: any }; +>z : { [index: number]: any; } +>index : number + +x = y; // Error +>x = y : { [index: string]: any; } +>x : { one: number; } +>y : { [index: string]: any; } + +y = x; // Ok because index signature type is any +>y = x : { one: number; } +>y : { [index: string]: any; } +>x : { one: number; } + +x = z; // Error +>x = z : { [index: number]: any; } +>x : { one: number; } +>z : { [index: number]: any; } + +z = x; // Ok because index signature type is any +>z = x : { one: number; } +>z : { [index: number]: any; } +>x : { one: number; } + +y = "foo"; // Error +>y = "foo" : "foo" +>y : { [index: string]: any; } +>"foo" : "foo" + +z = "foo"; // OK, string has numeric indexer +>z = "foo" : "foo" +>z : { [index: number]: any; } +>"foo" : "foo" + +z = false; // Error +>z = false : false +>z : { [index: number]: any; } +>false : false + + diff --git a/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.symbols b/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.symbols new file mode 100644 index 00000000000..0558393c631 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatBetweenTupleAndArray.ts === +var numStrTuple: [number, string]; +>numStrTuple : Symbol(numStrTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 0, 3)) + +var numNumTuple: [number, number]; +>numNumTuple : Symbol(numNumTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 1, 3)) + +var numEmptyObjTuple: [number, {}]; +>numEmptyObjTuple : Symbol(numEmptyObjTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 2, 3)) + +var emptyObjTuple: [{}]; +>emptyObjTuple : Symbol(emptyObjTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 3, 3)) + +var numArray: number[]; +>numArray : Symbol(numArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 5, 3)) + +var emptyObjArray: {}[]; +>emptyObjArray : Symbol(emptyObjArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 6, 3)) + +// no error +numArray = numNumTuple; +>numArray : Symbol(numArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 5, 3)) +>numNumTuple : Symbol(numNumTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 1, 3)) + +emptyObjArray = emptyObjTuple; +>emptyObjArray : Symbol(emptyObjArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 6, 3)) +>emptyObjTuple : Symbol(emptyObjTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 3, 3)) + +emptyObjArray = numStrTuple; +>emptyObjArray : Symbol(emptyObjArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 6, 3)) +>numStrTuple : Symbol(numStrTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 0, 3)) + +emptyObjArray = numNumTuple; +>emptyObjArray : Symbol(emptyObjArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 6, 3)) +>numNumTuple : Symbol(numNumTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 1, 3)) + +emptyObjArray = numEmptyObjTuple; +>emptyObjArray : Symbol(emptyObjArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 6, 3)) +>numEmptyObjTuple : Symbol(numEmptyObjTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 2, 3)) + +// error +numArray = numStrTuple; +>numArray : Symbol(numArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 5, 3)) +>numStrTuple : Symbol(numStrTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 0, 3)) + +emptyObjTuple = emptyObjArray; +>emptyObjTuple : Symbol(emptyObjTuple, Decl(assignmentCompatBetweenTupleAndArray.ts, 3, 3)) +>emptyObjArray : Symbol(emptyObjArray, Decl(assignmentCompatBetweenTupleAndArray.ts, 6, 3)) + diff --git a/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.types b/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.types new file mode 100644 index 00000000000..7d4750d02fa --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.types @@ -0,0 +1,56 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatBetweenTupleAndArray.ts === +var numStrTuple: [number, string]; +>numStrTuple : [number, string] + +var numNumTuple: [number, number]; +>numNumTuple : [number, number] + +var numEmptyObjTuple: [number, {}]; +>numEmptyObjTuple : [number, {}] + +var emptyObjTuple: [{}]; +>emptyObjTuple : [{}] + +var numArray: number[]; +>numArray : number[] + +var emptyObjArray: {}[]; +>emptyObjArray : {}[] + +// no error +numArray = numNumTuple; +>numArray = numNumTuple : [number, number] +>numArray : number[] +>numNumTuple : [number, number] + +emptyObjArray = emptyObjTuple; +>emptyObjArray = emptyObjTuple : [{}] +>emptyObjArray : {}[] +>emptyObjTuple : [{}] + +emptyObjArray = numStrTuple; +>emptyObjArray = numStrTuple : [number, string] +>emptyObjArray : {}[] +>numStrTuple : [number, string] + +emptyObjArray = numNumTuple; +>emptyObjArray = numNumTuple : [number, number] +>emptyObjArray : {}[] +>numNumTuple : [number, number] + +emptyObjArray = numEmptyObjTuple; +>emptyObjArray = numEmptyObjTuple : [number, {}] +>emptyObjArray : {}[] +>numEmptyObjTuple : [number, {}] + +// error +numArray = numStrTuple; +>numArray = numStrTuple : [number, string] +>numArray : number[] +>numStrTuple : [number, string] + +emptyObjTuple = emptyObjArray; +>emptyObjTuple = emptyObjArray : {}[] +>emptyObjTuple : [{}] +>emptyObjArray : {}[] + diff --git a/tests/baselines/reference/assignmentCompatBug2.symbols b/tests/baselines/reference/assignmentCompatBug2.symbols new file mode 100644 index 00000000000..d34000b6fa7 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBug2.symbols @@ -0,0 +1,109 @@ +=== tests/cases/compiler/assignmentCompatBug2.ts === +var b2: { b: number;} = { a: 0 }; // error +>b2 : Symbol(b2, Decl(assignmentCompatBug2.ts, 0, 3)) +>b : Symbol(b, Decl(assignmentCompatBug2.ts, 0, 9)) +>a : Symbol(a, Decl(assignmentCompatBug2.ts, 0, 25)) + +b2 = { a: 0 }; // error +>b2 : Symbol(b2, Decl(assignmentCompatBug2.ts, 0, 3)) +>a : Symbol(a, Decl(assignmentCompatBug2.ts, 2, 6)) + +b2 = {b: 0, a: 0 }; +>b2 : Symbol(b2, Decl(assignmentCompatBug2.ts, 0, 3)) +>b : Symbol(b, Decl(assignmentCompatBug2.ts, 4, 6)) +>a : Symbol(a, Decl(assignmentCompatBug2.ts, 4, 11)) + +var b3: { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }; +>b3 : Symbol(b3, Decl(assignmentCompatBug2.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatBug2.ts, 6, 9)) +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 6, 12)) +>g : Symbol(g, Decl(assignmentCompatBug2.ts, 6, 31)) +>s : Symbol(s, Decl(assignmentCompatBug2.ts, 6, 34)) +>m : Symbol(m, Decl(assignmentCompatBug2.ts, 6, 53)) +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 6, 64)) +>k : Symbol(k, Decl(assignmentCompatBug2.ts, 6, 76)) +>a : Symbol(a, Decl(assignmentCompatBug2.ts, 6, 80)) + +b3 = { +>b3 : Symbol(b3, Decl(assignmentCompatBug2.ts, 6, 3)) + + f: (n) => { return 0; }, +>f : Symbol(f, Decl(assignmentCompatBug2.ts, 8, 6)) +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 9, 8)) + + g: (s) => { return 0; }, +>g : Symbol(g, Decl(assignmentCompatBug2.ts, 9, 28)) +>s : Symbol(s, Decl(assignmentCompatBug2.ts, 10, 8)) + + m: 0, +>m : Symbol(m, Decl(assignmentCompatBug2.ts, 10, 28)) + +}; // ok + +b3 = { +>b3 : Symbol(b3, Decl(assignmentCompatBug2.ts, 6, 3)) + + f: (n) => { return 0; }, +>f : Symbol(f, Decl(assignmentCompatBug2.ts, 14, 6)) +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 15, 8)) + + g: (s) => { return 0; }, +>g : Symbol(g, Decl(assignmentCompatBug2.ts, 15, 28)) +>s : Symbol(s, Decl(assignmentCompatBug2.ts, 16, 8)) + +}; // error + +b3 = { +>b3 : Symbol(b3, Decl(assignmentCompatBug2.ts, 6, 3)) + + f: (n) => { return 0; }, +>f : Symbol(f, Decl(assignmentCompatBug2.ts, 19, 6)) +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 20, 8)) + + m: 0, +>m : Symbol(m, Decl(assignmentCompatBug2.ts, 20, 28)) + +}; // error + +b3 = { +>b3 : Symbol(b3, Decl(assignmentCompatBug2.ts, 6, 3)) + + f: (n) => { return 0; }, +>f : Symbol(f, Decl(assignmentCompatBug2.ts, 24, 6)) +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 25, 8)) + + g: (s) => { return 0; }, +>g : Symbol(g, Decl(assignmentCompatBug2.ts, 25, 28)) +>s : Symbol(s, Decl(assignmentCompatBug2.ts, 26, 8)) + + m: 0, +>m : Symbol(m, Decl(assignmentCompatBug2.ts, 26, 28)) + + n: 0, +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 27, 9)) + + k: (a) =>{ return null; }, +>k : Symbol(k, Decl(assignmentCompatBug2.ts, 28, 9)) +>a : Symbol(a, Decl(assignmentCompatBug2.ts, 29, 8)) + +}; // ok + +b3 = { +>b3 : Symbol(b3, Decl(assignmentCompatBug2.ts, 6, 3)) + + f: (n) => { return 0; }, +>f : Symbol(f, Decl(assignmentCompatBug2.ts, 32, 6)) +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 33, 8)) + + g: (s) => { return 0; }, +>g : Symbol(g, Decl(assignmentCompatBug2.ts, 33, 28)) +>s : Symbol(s, Decl(assignmentCompatBug2.ts, 34, 8)) + + n: 0, +>n : Symbol(n, Decl(assignmentCompatBug2.ts, 34, 28)) + + k: (a) =>{ return null; }, +>k : Symbol(k, Decl(assignmentCompatBug2.ts, 35, 9)) +>a : Symbol(a, Decl(assignmentCompatBug2.ts, 36, 8)) + +}; // error diff --git a/tests/baselines/reference/assignmentCompatBug2.types b/tests/baselines/reference/assignmentCompatBug2.types new file mode 100644 index 00000000000..414f91b5bdc --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBug2.types @@ -0,0 +1,155 @@ +=== tests/cases/compiler/assignmentCompatBug2.ts === +var b2: { b: number;} = { a: 0 }; // error +>b2 : { b: number; } +>b : number +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 + +b2 = { a: 0 }; // error +>b2 = { a: 0 } : { a: number; } +>b2 : { b: number; } +>{ a: 0 } : { a: number; } +>a : number +>0 : 0 + +b2 = {b: 0, a: 0 }; +>b2 = {b: 0, a: 0 } : { b: number; a: number; } +>b2 : { b: number; } +>{b: 0, a: 0 } : { b: number; a: number; } +>b : number +>0 : 0 +>a : number +>0 : 0 + +var b3: { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }; +>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } +>f : (n: number) => number +>n : number +>g : (s: string) => number +>s : string +>m : number +>n : number +>k : (a: any) => any +>a : any + +b3 = { +>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0,} : { f: (n: number) => number; g: (s: string) => number; m: number; } +>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } +>{ f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0,} : { f: (n: number) => number; g: (s: string) => number; m: number; } + + f: (n) => { return 0; }, +>f : (n: number) => number +>(n) => { return 0; } : (n: number) => number +>n : number +>0 : 0 + + g: (s) => { return 0; }, +>g : (s: string) => number +>(s) => { return 0; } : (s: string) => number +>s : string +>0 : 0 + + m: 0, +>m : number +>0 : 0 + +}; // ok + +b3 = { +>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; },} : { f: (n: number) => number; g: (s: string) => number; } +>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } +>{ f: (n) => { return 0; }, g: (s) => { return 0; },} : { f: (n: number) => number; g: (s: string) => number; } + + f: (n) => { return 0; }, +>f : (n: number) => number +>(n) => { return 0; } : (n: number) => number +>n : number +>0 : 0 + + g: (s) => { return 0; }, +>g : (s: string) => number +>(s) => { return 0; } : (s: string) => number +>s : string +>0 : 0 + +}; // error + +b3 = { +>b3 = { f: (n) => { return 0; }, m: 0,} : { f: (n: number) => number; m: number; } +>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } +>{ f: (n) => { return 0; }, m: 0,} : { f: (n: number) => number; m: number; } + + f: (n) => { return 0; }, +>f : (n: number) => number +>(n) => { return 0; } : (n: number) => number +>n : number +>0 : 0 + + m: 0, +>m : number +>0 : 0 + +}; // error + +b3 = { +>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => any; } +>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } +>{ f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => any; } + + f: (n) => { return 0; }, +>f : (n: number) => number +>(n) => { return 0; } : (n: number) => number +>n : number +>0 : 0 + + g: (s) => { return 0; }, +>g : (s: string) => number +>(s) => { return 0; } : (s: string) => number +>s : string +>0 : 0 + + m: 0, +>m : number +>0 : 0 + + n: 0, +>n : number +>0 : 0 + + k: (a) =>{ return null; }, +>k : (a: any) => any +>(a) =>{ return null; } : (a: any) => any +>a : any +>null : null + +}; // ok + +b3 = { +>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; } +>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; } +>{ f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; } + + f: (n) => { return 0; }, +>f : (n: number) => number +>(n) => { return 0; } : (n: number) => number +>n : number +>0 : 0 + + g: (s) => { return 0; }, +>g : (s: string) => number +>(s) => { return 0; } : (s: string) => number +>s : string +>0 : 0 + + n: 0, +>n : number +>0 : 0 + + k: (a) =>{ return null; }, +>k : (a: any) => any +>(a) =>{ return null; } : (a: any) => any +>a : any +>null : null + +}; // error diff --git a/tests/baselines/reference/assignmentCompatBug3.symbols b/tests/baselines/reference/assignmentCompatBug3.symbols new file mode 100644 index 00000000000..6545195d4b8 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBug3.symbols @@ -0,0 +1,61 @@ +=== tests/cases/compiler/assignmentCompatBug3.ts === +function makePoint(x: number, y: number) { +>makePoint : Symbol(makePoint, Decl(assignmentCompatBug3.ts, 0, 0)) +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 0, 19)) +>y : Symbol(y, Decl(assignmentCompatBug3.ts, 0, 29)) + + return { + get x() { return x;}, // shouldn't be "void" +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 1, 12)) +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 0, 19)) + + get y() { return y;}, // shouldn't be "void" +>y : Symbol(y, Decl(assignmentCompatBug3.ts, 2, 29)) +>y : Symbol(y, Decl(assignmentCompatBug3.ts, 0, 29)) + + //x: "yo", + //y: "boo", + dist: function () { +>dist : Symbol(dist, Decl(assignmentCompatBug3.ts, 3, 29)) + + return Math.sqrt(x*x+y*y); // shouldn't be picking up "x" and "y" from the object lit +>Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 0, 19)) +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 0, 19)) +>y : Symbol(y, Decl(assignmentCompatBug3.ts, 0, 29)) +>y : Symbol(y, Decl(assignmentCompatBug3.ts, 0, 29)) + } + } +} + +class C { +>C : Symbol(C, Decl(assignmentCompatBug3.ts, 10, 1)) + + get x() { +>x : Symbol(C.x, Decl(assignmentCompatBug3.ts, 12, 9)) + + return 0; + } +} + +function foo(test: string) { } +>foo : Symbol(foo, Decl(assignmentCompatBug3.ts, 16, 1)) +>test : Symbol(test, Decl(assignmentCompatBug3.ts, 18, 13)) + +var x: any; +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 20, 3)) + +var y: any; +>y : Symbol(y, Decl(assignmentCompatBug3.ts, 21, 3)) + +foo(x); +>foo : Symbol(foo, Decl(assignmentCompatBug3.ts, 16, 1)) +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 20, 3)) + +foo(x + y); +>foo : Symbol(foo, Decl(assignmentCompatBug3.ts, 16, 1)) +>x : Symbol(x, Decl(assignmentCompatBug3.ts, 20, 3)) +>y : Symbol(y, Decl(assignmentCompatBug3.ts, 21, 3)) + diff --git a/tests/baselines/reference/assignmentCompatBug3.types b/tests/baselines/reference/assignmentCompatBug3.types new file mode 100644 index 00000000000..1c4581e2f19 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBug3.types @@ -0,0 +1,72 @@ +=== tests/cases/compiler/assignmentCompatBug3.ts === +function makePoint(x: number, y: number) { +>makePoint : (x: number, y: number) => { readonly x: number; readonly y: number; dist: () => number; } +>x : number +>y : number + + return { +>{ get x() { return x;}, // shouldn't be "void" get y() { return y;}, // shouldn't be "void" //x: "yo", //y: "boo", dist: function () { return Math.sqrt(x*x+y*y); // shouldn't be picking up "x" and "y" from the object lit } } : { readonly x: number; readonly y: number; dist: () => number; } + + get x() { return x;}, // shouldn't be "void" +>x : number +>x : number + + get y() { return y;}, // shouldn't be "void" +>y : number +>y : number + + //x: "yo", + //y: "boo", + dist: function () { +>dist : () => number +>function () { return Math.sqrt(x*x+y*y); // shouldn't be picking up "x" and "y" from the object lit } : () => number + + return Math.sqrt(x*x+y*y); // shouldn't be picking up "x" and "y" from the object lit +>Math.sqrt(x*x+y*y) : number +>Math.sqrt : (x: number) => number +>Math : Math +>sqrt : (x: number) => number +>x*x+y*y : number +>x*x : number +>x : number +>x : number +>y*y : number +>y : number +>y : number + } + } +} + +class C { +>C : C + + get x() { +>x : number + + return 0; +>0 : 0 + } +} + +function foo(test: string) { } +>foo : (test: string) => void +>test : string + +var x: any; +>x : any + +var y: any; +>y : any + +foo(x); +>foo(x) : void +>foo : (test: string) => void +>x : any + +foo(x + y); +>foo(x + y) : void +>foo : (test: string) => void +>x + y : any +>x : any +>y : any + diff --git a/tests/baselines/reference/assignmentCompatBug5.symbols b/tests/baselines/reference/assignmentCompatBug5.symbols new file mode 100644 index 00000000000..63d4af123b4 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBug5.symbols @@ -0,0 +1,31 @@ +=== tests/cases/compiler/assignmentCompatBug5.ts === +function foo1(x: { a: number; }) { } +>foo1 : Symbol(foo1, Decl(assignmentCompatBug5.ts, 0, 0)) +>x : Symbol(x, Decl(assignmentCompatBug5.ts, 0, 14)) +>a : Symbol(a, Decl(assignmentCompatBug5.ts, 0, 18)) + +foo1({ b: 5 }); +>foo1 : Symbol(foo1, Decl(assignmentCompatBug5.ts, 0, 0)) +>b : Symbol(b, Decl(assignmentCompatBug5.ts, 1, 6)) + +function foo2(x: number[]) { } +>foo2 : Symbol(foo2, Decl(assignmentCompatBug5.ts, 1, 15)) +>x : Symbol(x, Decl(assignmentCompatBug5.ts, 3, 14)) + +foo2(["s", "t"]); +>foo2 : Symbol(foo2, Decl(assignmentCompatBug5.ts, 1, 15)) + +function foo3(x: (n: number) =>number) { }; +>foo3 : Symbol(foo3, Decl(assignmentCompatBug5.ts, 4, 17)) +>x : Symbol(x, Decl(assignmentCompatBug5.ts, 6, 14)) +>n : Symbol(n, Decl(assignmentCompatBug5.ts, 6, 18)) + +foo3((s:string) => { }); +>foo3 : Symbol(foo3, Decl(assignmentCompatBug5.ts, 4, 17)) +>s : Symbol(s, Decl(assignmentCompatBug5.ts, 7, 6)) + +foo3((n) => { return; }); +>foo3 : Symbol(foo3, Decl(assignmentCompatBug5.ts, 4, 17)) +>n : Symbol(n, Decl(assignmentCompatBug5.ts, 8, 6)) + + diff --git a/tests/baselines/reference/assignmentCompatBug5.types b/tests/baselines/reference/assignmentCompatBug5.types new file mode 100644 index 00000000000..2b8358bb27f --- /dev/null +++ b/tests/baselines/reference/assignmentCompatBug5.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatBug5.ts === +function foo1(x: { a: number; }) { } +>foo1 : (x: { a: number; }) => void +>x : { a: number; } +>a : number + +foo1({ b: 5 }); +>foo1({ b: 5 }) : void +>foo1 : (x: { a: number; }) => void +>{ b: 5 } : { b: number; } +>b : number +>5 : 5 + +function foo2(x: number[]) { } +>foo2 : (x: number[]) => void +>x : number[] + +foo2(["s", "t"]); +>foo2(["s", "t"]) : void +>foo2 : (x: number[]) => void +>["s", "t"] : string[] +>"s" : "s" +>"t" : "t" + +function foo3(x: (n: number) =>number) { }; +>foo3 : (x: (n: number) => number) => void +>x : (n: number) => number +>n : number + +foo3((s:string) => { }); +>foo3((s:string) => { }) : void +>foo3 : (x: (n: number) => number) => void +>(s:string) => { } : (s: string) => void +>s : string + +foo3((n) => { return; }); +>foo3((n) => { return; }) : void +>foo3 : (x: (n: number) => number) => void +>(n) => { return; } : (n: number) => void +>n : number + + diff --git a/tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.symbols b/tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.symbols new file mode 100644 index 00000000000..e0a2d00ac34 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.symbols @@ -0,0 +1,25 @@ +=== tests/cases/compiler/assignmentCompatFunctionsWithOptionalArgs.ts === +function foo(x: { id: number; name?: string; }): void; +>foo : Symbol(foo, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 0)) +>x : Symbol(x, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 13)) +>id : Symbol(id, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 17)) +>name : Symbol(name, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 29)) + +foo({ id: 1234 }); // Ok +>foo : Symbol(foo, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 0)) +>id : Symbol(id, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 1, 5)) + +foo({ id: 1234, name: "hello" }); // Ok +>foo : Symbol(foo, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 0)) +>id : Symbol(id, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 2, 5)) +>name : Symbol(name, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 2, 15)) + +foo({ id: 1234, name: false }); // Error, name of wrong type +>foo : Symbol(foo, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 0)) +>id : Symbol(id, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 3, 5)) +>name : Symbol(name, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 3, 15)) + +foo({ name: "hello" }); // Error, id required but missing +>foo : Symbol(foo, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 0, 0)) +>name : Symbol(name, Decl(assignmentCompatFunctionsWithOptionalArgs.ts, 4, 5)) + diff --git a/tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.types b/tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.types new file mode 100644 index 00000000000..1f1beea0b38 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.types @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatFunctionsWithOptionalArgs.ts === +function foo(x: { id: number; name?: string; }): void; +>foo : (x: { id: number; name?: string; }) => void +>x : { id: number; name?: string; } +>id : number +>name : string + +foo({ id: 1234 }); // Ok +>foo({ id: 1234 }) : void +>foo : (x: { id: number; name?: string; }) => void +>{ id: 1234 } : { id: number; } +>id : number +>1234 : 1234 + +foo({ id: 1234, name: "hello" }); // Ok +>foo({ id: 1234, name: "hello" }) : void +>foo : (x: { id: number; name?: string; }) => void +>{ id: 1234, name: "hello" } : { id: number; name: string; } +>id : number +>1234 : 1234 +>name : string +>"hello" : "hello" + +foo({ id: 1234, name: false }); // Error, name of wrong type +>foo({ id: 1234, name: false }) : void +>foo : (x: { id: number; name?: string; }) => void +>{ id: 1234, name: false } : { id: number; name: boolean; } +>id : number +>1234 : 1234 +>name : boolean +>false : false + +foo({ name: "hello" }); // Error, id required but missing +>foo({ name: "hello" }) : void +>foo : (x: { id: number; name?: string; }) => void +>{ name: "hello" } : { name: string; } +>name : string +>"hello" : "hello" + diff --git a/tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.symbols b/tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.symbols new file mode 100644 index 00000000000..2fa181500ae --- /dev/null +++ b/tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.symbols @@ -0,0 +1,32 @@ +=== tests/cases/compiler/assignmentCompatInterfaceWithStringIndexSignature.ts === +interface IHandler { +>IHandler : Symbol(IHandler, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 0, 0)) + + (e): boolean; +>e : Symbol(e, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 1, 5)) +} + +interface IHandlerMap { +>IHandlerMap : Symbol(IHandlerMap, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 2, 1)) + + [type: string]: IHandler; +>type : Symbol(type, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 5, 5)) +>IHandler : Symbol(IHandler, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 0, 0)) +} + +class Foo { +>Foo : Symbol(Foo, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 6, 1)) + + public Boz(): void { } +>Boz : Symbol(Foo.Boz, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 8, 11)) +} + +function Biz(map: IHandlerMap) { } +>Biz : Symbol(Biz, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 10, 1)) +>map : Symbol(map, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 12, 13)) +>IHandlerMap : Symbol(IHandlerMap, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 2, 1)) + +Biz(new Foo()); +>Biz : Symbol(Biz, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 10, 1)) +>Foo : Symbol(Foo, Decl(assignmentCompatInterfaceWithStringIndexSignature.ts, 6, 1)) + diff --git a/tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.types b/tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.types new file mode 100644 index 00000000000..57371756706 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.types @@ -0,0 +1,34 @@ +=== tests/cases/compiler/assignmentCompatInterfaceWithStringIndexSignature.ts === +interface IHandler { +>IHandler : IHandler + + (e): boolean; +>e : any +} + +interface IHandlerMap { +>IHandlerMap : IHandlerMap + + [type: string]: IHandler; +>type : string +>IHandler : IHandler +} + +class Foo { +>Foo : Foo + + public Boz(): void { } +>Boz : () => void +} + +function Biz(map: IHandlerMap) { } +>Biz : (map: IHandlerMap) => void +>map : IHandlerMap +>IHandlerMap : IHandlerMap + +Biz(new Foo()); +>Biz(new Foo()) : void +>Biz : (map: IHandlerMap) => void +>new Foo() : Foo +>Foo : typeof Foo + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures.symbols b/tests/baselines/reference/assignmentCompatWithCallSignatures.symbols new file mode 100644 index 00000000000..26e3701c0e3 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignatures.symbols @@ -0,0 +1,128 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures.ts, 0, 0)) + + (x: number): void; +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 3, 5)) +} +var t: T; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures.ts, 0, 0)) + +var a: { (x: number): void }; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 6, 10)) + +t = a; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) + +a = t; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) + +interface S { +>S : Symbol(S, Decl(assignmentCompatWithCallSignatures.ts, 9, 6)) + + (x: number): string; +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 12, 5)) +} +var s: S; +>s : Symbol(s, Decl(assignmentCompatWithCallSignatures.ts, 14, 3)) +>S : Symbol(S, Decl(assignmentCompatWithCallSignatures.ts, 9, 6)) + +var a2: { (x: number): string }; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures.ts, 15, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 15, 11)) + +t = s; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>s : Symbol(s, Decl(assignmentCompatWithCallSignatures.ts, 14, 3)) + +t = a2; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures.ts, 15, 3)) + +a = s; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>s : Symbol(s, Decl(assignmentCompatWithCallSignatures.ts, 14, 3)) + +a = a2; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures.ts, 15, 3)) + +t = (x: T) => 1; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures.ts, 21, 5)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 21, 8)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures.ts, 21, 5)) + +t = () => 1; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) + +t = function (x: number) { return ''; } +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 23, 14)) + +a = (x: T) => 1; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures.ts, 24, 5)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 24, 8)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures.ts, 24, 5)) + +a = () => 1; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) + +a = function (x: number) { return ''; } +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 26, 14)) + +interface S2 { +>S2 : Symbol(S2, Decl(assignmentCompatWithCallSignatures.ts, 26, 39)) + + (x: string): void; +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 29, 5)) +} +var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithCallSignatures.ts, 31, 3)) +>S2 : Symbol(S2, Decl(assignmentCompatWithCallSignatures.ts, 26, 39)) + +var a3: { (x: string): void }; +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures.ts, 32, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 32, 11)) + +// these are errors +t = s2; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithCallSignatures.ts, 31, 3)) + +t = a3; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures.ts, 32, 3)) + +t = (x: string) => 1; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 36, 5)) + +t = function (x: string) { return ''; } +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 37, 14)) + +a = s2; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithCallSignatures.ts, 31, 3)) + +a = a3; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures.ts, 32, 3)) + +a = (x: string) => 1; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 40, 5)) + +a = function (x: string) { return ''; } +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures.ts, 41, 14)) + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures.types b/tests/baselines/reference/assignmentCompatWithCallSignatures.types new file mode 100644 index 00000000000..f7faedf91e3 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignatures.types @@ -0,0 +1,168 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : T + + (x: number): void; +>x : number +} +var t: T; +>t : T +>T : T + +var a: { (x: number): void }; +>a : (x: number) => void +>x : number + +t = a; +>t = a : (x: number) => void +>t : T +>a : (x: number) => void + +a = t; +>a = t : T +>a : (x: number) => void +>t : T + +interface S { +>S : S + + (x: number): string; +>x : number +} +var s: S; +>s : S +>S : S + +var a2: { (x: number): string }; +>a2 : (x: number) => string +>x : number + +t = s; +>t = s : S +>t : T +>s : S + +t = a2; +>t = a2 : (x: number) => string +>t : T +>a2 : (x: number) => string + +a = s; +>a = s : S +>a : (x: number) => void +>s : S + +a = a2; +>a = a2 : (x: number) => string +>a : (x: number) => void +>a2 : (x: number) => string + +t = (x: T) => 1; +>t = (x: T) => 1 : (x: T) => number +>t : T +>(x: T) => 1 : (x: T) => number +>T : T +>x : T +>T : T +>1 : 1 + +t = () => 1; +>t = () => 1 : () => number +>t : T +>() => 1 : () => number +>1 : 1 + +t = function (x: number) { return ''; } +>t = function (x: number) { return ''; } : (x: number) => string +>t : T +>function (x: number) { return ''; } : (x: number) => string +>x : number +>'' : "" + +a = (x: T) => 1; +>a = (x: T) => 1 : (x: T) => number +>a : (x: number) => void +>(x: T) => 1 : (x: T) => number +>T : T +>x : T +>T : T +>1 : 1 + +a = () => 1; +>a = () => 1 : () => number +>a : (x: number) => void +>() => 1 : () => number +>1 : 1 + +a = function (x: number) { return ''; } +>a = function (x: number) { return ''; } : (x: number) => string +>a : (x: number) => void +>function (x: number) { return ''; } : (x: number) => string +>x : number +>'' : "" + +interface S2 { +>S2 : S2 + + (x: string): void; +>x : string +} +var s2: S2; +>s2 : S2 +>S2 : S2 + +var a3: { (x: string): void }; +>a3 : (x: string) => void +>x : string + +// these are errors +t = s2; +>t = s2 : S2 +>t : T +>s2 : S2 + +t = a3; +>t = a3 : (x: string) => void +>t : T +>a3 : (x: string) => void + +t = (x: string) => 1; +>t = (x: string) => 1 : (x: string) => number +>t : T +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +t = function (x: string) { return ''; } +>t = function (x: string) { return ''; } : (x: string) => string +>t : T +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + +a = s2; +>a = s2 : S2 +>a : (x: number) => void +>s2 : S2 + +a = a3; +>a = a3 : (x: string) => void +>a : (x: number) => void +>a3 : (x: string) => void + +a = (x: string) => 1; +>a = (x: string) => 1 : (x: string) => number +>a : (x: number) => void +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +a = function (x: string) { return ''; } +>a = function (x: string) { return ''; } : (x: string) => string +>a : (x: number) => void +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures2.symbols b/tests/baselines/reference/assignmentCompatWithCallSignatures2.symbols new file mode 100644 index 00000000000..267aea9fa5f --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignatures2.symbols @@ -0,0 +1,160 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures2.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures2.ts, 0, 0)) + + f(x: number): void; +>f : Symbol(T.f, Decl(assignmentCompatWithCallSignatures2.ts, 2, 13)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 3, 6)) +} +var t: T; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures2.ts, 0, 0)) + +var a: { f(x: number): void }; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 6, 8)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 6, 11)) + +t = a; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) + +a = t; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) + +interface S { +>S : Symbol(S, Decl(assignmentCompatWithCallSignatures2.ts, 9, 6)) + + f(x: number): string; +>f : Symbol(S.f, Decl(assignmentCompatWithCallSignatures2.ts, 11, 13)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 12, 6)) +} +var s: S; +>s : Symbol(s, Decl(assignmentCompatWithCallSignatures2.ts, 14, 3)) +>S : Symbol(S, Decl(assignmentCompatWithCallSignatures2.ts, 9, 6)) + +var a2: { f(x: number): string }; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures2.ts, 15, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 15, 9)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 15, 12)) + +t = s; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>s : Symbol(s, Decl(assignmentCompatWithCallSignatures2.ts, 14, 3)) + +t = a2; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures2.ts, 15, 3)) + +a = s; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>s : Symbol(s, Decl(assignmentCompatWithCallSignatures2.ts, 14, 3)) + +a = a2; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures2.ts, 15, 3)) + +t = { f: () => 1 }; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 21, 5)) + +t = { f: (x:T) => 1 }; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 22, 5)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures2.ts, 22, 10)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 22, 13)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures2.ts, 22, 10)) + +t = { f: function f() { return 1 } }; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 23, 5)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 23, 8)) + +t = { f(x: number) { return ''; } } +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 24, 5)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 24, 8)) + +a = { f: () => 1 } +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 25, 5)) + +a = { f: (x: T) => 1 }; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 26, 5)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures2.ts, 26, 10)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 26, 13)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures2.ts, 26, 10)) + +a = { f: function (x: number) { return ''; } } +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 27, 5)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 27, 19)) + +// errors +t = () => 1; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) + +t = function (x: number) { return ''; } +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 31, 14)) + +a = () => 1; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) + +a = function (x: number) { return ''; } +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 33, 14)) + +interface S2 { +>S2 : Symbol(S2, Decl(assignmentCompatWithCallSignatures2.ts, 33, 39)) + + f(x: string): void; +>f : Symbol(S2.f, Decl(assignmentCompatWithCallSignatures2.ts, 35, 14)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 36, 6)) +} +var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithCallSignatures2.ts, 38, 3)) +>S2 : Symbol(S2, Decl(assignmentCompatWithCallSignatures2.ts, 33, 39)) + +var a3: { f(x: string): void }; +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures2.ts, 39, 3)) +>f : Symbol(f, Decl(assignmentCompatWithCallSignatures2.ts, 39, 9)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 39, 12)) + +// these are errors +t = s2; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithCallSignatures2.ts, 38, 3)) + +t = a3; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures2.ts, 39, 3)) + +t = (x: string) => 1; +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 43, 5)) + +t = function (x: string) { return ''; } +>t : Symbol(t, Decl(assignmentCompatWithCallSignatures2.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 44, 14)) + +a = s2; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithCallSignatures2.ts, 38, 3)) + +a = a3; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures2.ts, 39, 3)) + +a = (x: string) => 1; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 47, 5)) + +a = function (x: string) { return ''; } +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures2.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures2.ts, 48, 14)) + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures2.types b/tests/baselines/reference/assignmentCompatWithCallSignatures2.types new file mode 100644 index 00000000000..f20b03dbcce --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignatures2.types @@ -0,0 +1,221 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures2.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : T + + f(x: number): void; +>f : (x: number) => void +>x : number +} +var t: T; +>t : T +>T : T + +var a: { f(x: number): void }; +>a : { f(x: number): void; } +>f : (x: number) => void +>x : number + +t = a; +>t = a : { f(x: number): void; } +>t : T +>a : { f(x: number): void; } + +a = t; +>a = t : T +>a : { f(x: number): void; } +>t : T + +interface S { +>S : S + + f(x: number): string; +>f : (x: number) => string +>x : number +} +var s: S; +>s : S +>S : S + +var a2: { f(x: number): string }; +>a2 : { f(x: number): string; } +>f : (x: number) => string +>x : number + +t = s; +>t = s : S +>t : T +>s : S + +t = a2; +>t = a2 : { f(x: number): string; } +>t : T +>a2 : { f(x: number): string; } + +a = s; +>a = s : S +>a : { f(x: number): void; } +>s : S + +a = a2; +>a = a2 : { f(x: number): string; } +>a : { f(x: number): void; } +>a2 : { f(x: number): string; } + +t = { f: () => 1 }; +>t = { f: () => 1 } : { f: () => number; } +>t : T +>{ f: () => 1 } : { f: () => number; } +>f : () => number +>() => 1 : () => number +>1 : 1 + +t = { f: (x:T) => 1 }; +>t = { f: (x:T) => 1 } : { f: (x: T) => number; } +>t : T +>{ f: (x:T) => 1 } : { f: (x: T) => number; } +>f : (x: T) => number +>(x:T) => 1 : (x: T) => number +>T : T +>x : T +>T : T +>1 : 1 + +t = { f: function f() { return 1 } }; +>t = { f: function f() { return 1 } } : { f: () => number; } +>t : T +>{ f: function f() { return 1 } } : { f: () => number; } +>f : () => number +>function f() { return 1 } : () => number +>f : () => number +>1 : 1 + +t = { f(x: number) { return ''; } } +>t = { f(x: number) { return ''; } } : { f(x: number): string; } +>t : T +>{ f(x: number) { return ''; } } : { f(x: number): string; } +>f : (x: number) => string +>x : number +>'' : "" + +a = { f: () => 1 } +>a = { f: () => 1 } : { f: () => number; } +>a : { f(x: number): void; } +>{ f: () => 1 } : { f: () => number; } +>f : () => number +>() => 1 : () => number +>1 : 1 + +a = { f: (x: T) => 1 }; +>a = { f: (x: T) => 1 } : { f: (x: T) => number; } +>a : { f(x: number): void; } +>{ f: (x: T) => 1 } : { f: (x: T) => number; } +>f : (x: T) => number +>(x: T) => 1 : (x: T) => number +>T : T +>x : T +>T : T +>1 : 1 + +a = { f: function (x: number) { return ''; } } +>a = { f: function (x: number) { return ''; } } : { f: (x: number) => string; } +>a : { f(x: number): void; } +>{ f: function (x: number) { return ''; } } : { f: (x: number) => string; } +>f : (x: number) => string +>function (x: number) { return ''; } : (x: number) => string +>x : number +>'' : "" + +// errors +t = () => 1; +>t = () => 1 : () => number +>t : T +>() => 1 : () => number +>1 : 1 + +t = function (x: number) { return ''; } +>t = function (x: number) { return ''; } : (x: number) => string +>t : T +>function (x: number) { return ''; } : (x: number) => string +>x : number +>'' : "" + +a = () => 1; +>a = () => 1 : () => number +>a : { f(x: number): void; } +>() => 1 : () => number +>1 : 1 + +a = function (x: number) { return ''; } +>a = function (x: number) { return ''; } : (x: number) => string +>a : { f(x: number): void; } +>function (x: number) { return ''; } : (x: number) => string +>x : number +>'' : "" + +interface S2 { +>S2 : S2 + + f(x: string): void; +>f : (x: string) => void +>x : string +} +var s2: S2; +>s2 : S2 +>S2 : S2 + +var a3: { f(x: string): void }; +>a3 : { f(x: string): void; } +>f : (x: string) => void +>x : string + +// these are errors +t = s2; +>t = s2 : S2 +>t : T +>s2 : S2 + +t = a3; +>t = a3 : { f(x: string): void; } +>t : T +>a3 : { f(x: string): void; } + +t = (x: string) => 1; +>t = (x: string) => 1 : (x: string) => number +>t : T +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +t = function (x: string) { return ''; } +>t = function (x: string) { return ''; } : (x: string) => string +>t : T +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + +a = s2; +>a = s2 : S2 +>a : { f(x: number): void; } +>s2 : S2 + +a = a3; +>a = a3 : { f(x: string): void; } +>a : { f(x: number): void; } +>a3 : { f(x: string): void; } + +a = (x: string) => 1; +>a = (x: string) => 1 : (x: string) => number +>a : { f(x: number): void; } +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +a = function (x: string) { return ''; } +>a = function (x: string) { return ''; } : (x: string) => string +>a : { f(x: number): void; } +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures4.symbols b/tests/baselines/reference/assignmentCompatWithCallSignatures4.symbols new file mode 100644 index 00000000000..02d7a1a0bad --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignatures4.symbols @@ -0,0 +1,404 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures4.ts === +// These are mostly permitted with the current loose rules. All ok unless otherwise noted. + +module Errors { +>Errors : Symbol(Errors, Decl(assignmentCompatWithCallSignatures4.ts, 0, 0)) + + class Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithCallSignatures4.ts, 3, 16)) + + class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithCallSignatures4.ts, 4, 32)) + + class Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures4.ts, 4, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithCallSignatures4.ts, 5, 36)) + + class OtherDerived extends Base { bing: string; } +>OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithCallSignatures4.ts, 5, 51)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithCallSignatures4.ts, 6, 37)) + + module WithNonGenericSignaturesInBaseType { +>WithNonGenericSignaturesInBaseType : Symbol(WithNonGenericSignaturesInBaseType, Decl(assignmentCompatWithCallSignatures4.ts, 6, 53)) + + // target type with non-generic call signatures + var a2: (x: number) => string[]; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures4.ts, 10, 11)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 10, 17)) + + var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived2; +>a7 : Symbol(a7, Decl(assignmentCompatWithCallSignatures4.ts, 11, 11)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 11, 17)) +>arg : Symbol(arg, Decl(assignmentCompatWithCallSignatures4.ts, 11, 21)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>r : Symbol(r, Decl(assignmentCompatWithCallSignatures4.ts, 11, 48)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures4.ts, 4, 47)) + + var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived; +>a8 : Symbol(a8, Decl(assignmentCompatWithCallSignatures4.ts, 12, 11)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 12, 17)) +>arg : Symbol(arg, Decl(assignmentCompatWithCallSignatures4.ts, 12, 21)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignatures4.ts, 12, 43)) +>arg2 : Symbol(arg2, Decl(assignmentCompatWithCallSignatures4.ts, 12, 48)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>r : Symbol(r, Decl(assignmentCompatWithCallSignatures4.ts, 12, 76)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) + + var a10: (...x: Base[]) => Base; +>a10 : Symbol(a10, Decl(assignmentCompatWithCallSignatures4.ts, 13, 11)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 13, 18)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) + + var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base; +>a11 : Symbol(a11, Decl(assignmentCompatWithCallSignatures4.ts, 14, 11)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 14, 18)) +>foo : Symbol(foo, Decl(assignmentCompatWithCallSignatures4.ts, 14, 22)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignatures4.ts, 14, 37)) +>foo : Symbol(foo, Decl(assignmentCompatWithCallSignatures4.ts, 14, 42)) +>bar : Symbol(bar, Decl(assignmentCompatWithCallSignatures4.ts, 14, 55)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) + + var a12: (x: Array, y: Array) => Array; +>a12 : Symbol(a12, Decl(assignmentCompatWithCallSignatures4.ts, 15, 11)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 15, 18)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignatures4.ts, 15, 33)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures4.ts, 4, 47)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) + + var a14: { +>a14 : Symbol(a14, Decl(assignmentCompatWithCallSignatures4.ts, 16, 11)) + + (x: number): number[]; +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 17, 17)) + + (x: string): string[]; +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 18, 17)) + + }; + var a15: (x: { a: string; b: number }) => number; +>a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures4.ts, 20, 11)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 20, 18)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 20, 22)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignatures4.ts, 20, 33)) + + var a16: { +>a16 : Symbol(a16, Decl(assignmentCompatWithCallSignatures4.ts, 21, 11)) + + (x: { +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 22, 17)) + + (a: number): number; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 23, 21)) + + (a?: number): number; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 24, 21)) + + }): number[]; + (x: { +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 26, 17)) + + (a: boolean): boolean; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 27, 21)) + + (a?: boolean): boolean; +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 28, 21)) + + }): boolean[]; + }; + var a17: { +>a17 : Symbol(a17, Decl(assignmentCompatWithCallSignatures4.ts, 31, 11)) + + (x: { +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 32, 17)) + + (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 33, 21)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 33, 40)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 33, 21)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 33, 21)) + + (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 34, 21)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 34, 37)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 34, 21)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 34, 21)) + + }): any[]; + (x: { +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 36, 17)) + + (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 37, 21)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures4.ts, 4, 47)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 37, 41)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 37, 21)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 37, 21)) + + (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 38, 21)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 38, 37)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 38, 21)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 38, 21)) + + }): any[]; + }; + + var b2: (x: T) => U[]; +>b2 : Symbol(b2, Decl(assignmentCompatWithCallSignatures4.ts, 42, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 42, 17)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 42, 19)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 42, 23)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 42, 17)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 42, 19)) + + a2 = b2; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures4.ts, 10, 11)) +>b2 : Symbol(b2, Decl(assignmentCompatWithCallSignatures4.ts, 42, 11)) + + b2 = a2; +>b2 : Symbol(b2, Decl(assignmentCompatWithCallSignatures4.ts, 42, 11)) +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures4.ts, 10, 11)) + + var b7: (x: (arg: T) => U) => (r: T) => V; +>b7 : Symbol(b7, Decl(assignmentCompatWithCallSignatures4.ts, 46, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 46, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 46, 32)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>V : Symbol(V, Decl(assignmentCompatWithCallSignatures4.ts, 46, 51)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures4.ts, 4, 47)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 46, 72)) +>arg : Symbol(arg, Decl(assignmentCompatWithCallSignatures4.ts, 46, 76)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 46, 17)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 46, 32)) +>r : Symbol(r, Decl(assignmentCompatWithCallSignatures4.ts, 46, 94)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 46, 17)) +>V : Symbol(V, Decl(assignmentCompatWithCallSignatures4.ts, 46, 51)) + + a7 = b7; +>a7 : Symbol(a7, Decl(assignmentCompatWithCallSignatures4.ts, 11, 11)) +>b7 : Symbol(b7, Decl(assignmentCompatWithCallSignatures4.ts, 46, 11)) + + b7 = a7; +>b7 : Symbol(b7, Decl(assignmentCompatWithCallSignatures4.ts, 46, 11)) +>a7 : Symbol(a7, Decl(assignmentCompatWithCallSignatures4.ts, 11, 11)) + + var b8: (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; +>b8 : Symbol(b8, Decl(assignmentCompatWithCallSignatures4.ts, 50, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 50, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 50, 32)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 50, 52)) +>arg : Symbol(arg, Decl(assignmentCompatWithCallSignatures4.ts, 50, 56)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 50, 17)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 50, 32)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignatures4.ts, 50, 69)) +>arg2 : Symbol(arg2, Decl(assignmentCompatWithCallSignatures4.ts, 50, 74)) +>foo : Symbol(foo, Decl(assignmentCompatWithCallSignatures4.ts, 50, 81)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 50, 32)) +>r : Symbol(r, Decl(assignmentCompatWithCallSignatures4.ts, 50, 108)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 50, 17)) +>U : Symbol(U, Decl(assignmentCompatWithCallSignatures4.ts, 50, 32)) + + a8 = b8; // error, { foo: number } and Base are incompatible +>a8 : Symbol(a8, Decl(assignmentCompatWithCallSignatures4.ts, 12, 11)) +>b8 : Symbol(b8, Decl(assignmentCompatWithCallSignatures4.ts, 50, 11)) + + b8 = a8; // error, { foo: number } and Base are incompatible +>b8 : Symbol(b8, Decl(assignmentCompatWithCallSignatures4.ts, 50, 11)) +>a8 : Symbol(a8, Decl(assignmentCompatWithCallSignatures4.ts, 12, 11)) + + + var b10: (...x: T[]) => T; +>b10 : Symbol(b10, Decl(assignmentCompatWithCallSignatures4.ts, 55, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 55, 18)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 55, 37)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 55, 18)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 55, 18)) + + a10 = b10; +>a10 : Symbol(a10, Decl(assignmentCompatWithCallSignatures4.ts, 13, 11)) +>b10 : Symbol(b10, Decl(assignmentCompatWithCallSignatures4.ts, 55, 11)) + + b10 = a10; +>b10 : Symbol(b10, Decl(assignmentCompatWithCallSignatures4.ts, 55, 11)) +>a10 : Symbol(a10, Decl(assignmentCompatWithCallSignatures4.ts, 13, 11)) + + var b11: (x: T, y: T) => T; +>b11 : Symbol(b11, Decl(assignmentCompatWithCallSignatures4.ts, 59, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 59, 18)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures4.ts, 3, 31)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 59, 37)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 59, 18)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignatures4.ts, 59, 42)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 59, 18)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 59, 18)) + + a11 = b11; +>a11 : Symbol(a11, Decl(assignmentCompatWithCallSignatures4.ts, 14, 11)) +>b11 : Symbol(b11, Decl(assignmentCompatWithCallSignatures4.ts, 59, 11)) + + b11 = a11; +>b11 : Symbol(b11, Decl(assignmentCompatWithCallSignatures4.ts, 59, 11)) +>a11 : Symbol(a11, Decl(assignmentCompatWithCallSignatures4.ts, 14, 11)) + + var b12: >(x: Array, y: Array) => T; +>b12 : Symbol(b12, Decl(assignmentCompatWithCallSignatures4.ts, 63, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 63, 18)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures4.ts, 4, 47)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 63, 45)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignatures4.ts, 63, 60)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 63, 18)) + + a12 = b12; +>a12 : Symbol(a12, Decl(assignmentCompatWithCallSignatures4.ts, 15, 11)) +>b12 : Symbol(b12, Decl(assignmentCompatWithCallSignatures4.ts, 63, 11)) + + b12 = a12; +>b12 : Symbol(b12, Decl(assignmentCompatWithCallSignatures4.ts, 63, 11)) +>a12 : Symbol(a12, Decl(assignmentCompatWithCallSignatures4.ts, 15, 11)) + + var b15: (x: { a: T; b: T }) => T; +>b15 : Symbol(b15, Decl(assignmentCompatWithCallSignatures4.ts, 67, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 67, 18)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 67, 21)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 67, 25)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 67, 18)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignatures4.ts, 67, 31)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 67, 18)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 67, 18)) + + a15 = b15; +>a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures4.ts, 20, 11)) +>b15 : Symbol(b15, Decl(assignmentCompatWithCallSignatures4.ts, 67, 11)) + + b15 = a15; +>b15 : Symbol(b15, Decl(assignmentCompatWithCallSignatures4.ts, 67, 11)) +>a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures4.ts, 20, 11)) + + var b15a: (x: { a: T; b: T }) => number; +>b15a : Symbol(b15a, Decl(assignmentCompatWithCallSignatures4.ts, 71, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 71, 19)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures4.ts, 2, 15)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 71, 35)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 71, 39)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 71, 19)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignatures4.ts, 71, 45)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 71, 19)) + + a15 = b15a; +>a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures4.ts, 20, 11)) +>b15a : Symbol(b15a, Decl(assignmentCompatWithCallSignatures4.ts, 71, 11)) + + b15a = a15; +>b15a : Symbol(b15a, Decl(assignmentCompatWithCallSignatures4.ts, 71, 11)) +>a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures4.ts, 20, 11)) + + var b16: (x: (a: T) => T) => T[]; +>b16 : Symbol(b16, Decl(assignmentCompatWithCallSignatures4.ts, 75, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 75, 18)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 75, 21)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 75, 25)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 75, 18)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 75, 18)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 75, 18)) + + a16 = b16; +>a16 : Symbol(a16, Decl(assignmentCompatWithCallSignatures4.ts, 21, 11)) +>b16 : Symbol(b16, Decl(assignmentCompatWithCallSignatures4.ts, 75, 11)) + + b16 = a16; +>b16 : Symbol(b16, Decl(assignmentCompatWithCallSignatures4.ts, 75, 11)) +>a16 : Symbol(a16, Decl(assignmentCompatWithCallSignatures4.ts, 21, 11)) + + var b17: (x: (a: T) => T) => any[]; +>b17 : Symbol(b17, Decl(assignmentCompatWithCallSignatures4.ts, 79, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 79, 18)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 79, 21)) +>a : Symbol(a, Decl(assignmentCompatWithCallSignatures4.ts, 79, 25)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 79, 18)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 79, 18)) + + a17 = b17; +>a17 : Symbol(a17, Decl(assignmentCompatWithCallSignatures4.ts, 31, 11)) +>b17 : Symbol(b17, Decl(assignmentCompatWithCallSignatures4.ts, 79, 11)) + + b17 = a17; +>b17 : Symbol(b17, Decl(assignmentCompatWithCallSignatures4.ts, 79, 11)) +>a17 : Symbol(a17, Decl(assignmentCompatWithCallSignatures4.ts, 31, 11)) + } + + module WithGenericSignaturesInBaseType { +>WithGenericSignaturesInBaseType : Symbol(WithGenericSignaturesInBaseType, Decl(assignmentCompatWithCallSignatures4.ts, 82, 5)) + + // target type has generic call signature + var a2: (x: T) => T[]; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures4.ts, 86, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 86, 17)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 86, 20)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 86, 17)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 86, 17)) + + var b2: (x: T) => string[]; +>b2 : Symbol(b2, Decl(assignmentCompatWithCallSignatures4.ts, 87, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 87, 17)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 87, 20)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 87, 17)) + + a2 = b2; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures4.ts, 86, 11)) +>b2 : Symbol(b2, Decl(assignmentCompatWithCallSignatures4.ts, 87, 11)) + + b2 = a2; +>b2 : Symbol(b2, Decl(assignmentCompatWithCallSignatures4.ts, 87, 11)) +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignatures4.ts, 86, 11)) + + // target type has generic call signature + var a3: (x: T) => string[]; +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures4.ts, 92, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 92, 17)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 92, 20)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 92, 17)) + + var b3: (x: T) => T[]; +>b3 : Symbol(b3, Decl(assignmentCompatWithCallSignatures4.ts, 93, 11)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 93, 17)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignatures4.ts, 93, 20)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 93, 17)) +>T : Symbol(T, Decl(assignmentCompatWithCallSignatures4.ts, 93, 17)) + + a3 = b3; +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures4.ts, 92, 11)) +>b3 : Symbol(b3, Decl(assignmentCompatWithCallSignatures4.ts, 93, 11)) + + b3 = a3; +>b3 : Symbol(b3, Decl(assignmentCompatWithCallSignatures4.ts, 93, 11)) +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignatures4.ts, 92, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures4.types b/tests/baselines/reference/assignmentCompatWithCallSignatures4.types new file mode 100644 index 00000000000..4e4f3a836df --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignatures4.types @@ -0,0 +1,428 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures4.ts === +// These are mostly permitted with the current loose rules. All ok unless otherwise noted. + +module Errors { +>Errors : typeof Errors + + class Base { foo: string; } +>Base : Base +>foo : string + + class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + + class Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + + class OtherDerived extends Base { bing: string; } +>OtherDerived : OtherDerived +>Base : Base +>bing : string + + module WithNonGenericSignaturesInBaseType { +>WithNonGenericSignaturesInBaseType : typeof WithNonGenericSignaturesInBaseType + + // target type with non-generic call signatures + var a2: (x: number) => string[]; +>a2 : (x: number) => string[] +>x : number + + var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived2; +>a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived2 +>x : (arg: Base) => Derived +>arg : Base +>Base : Base +>Derived : Derived +>r : Base +>Base : Base +>Derived2 : Derived2 + + var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived; +>a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived +>x : (arg: Base) => Derived +>arg : Base +>Base : Base +>Derived : Derived +>y : (arg2: Base) => Derived +>arg2 : Base +>Base : Base +>Derived : Derived +>r : Base +>Base : Base +>Derived : Derived + + var a10: (...x: Base[]) => Base; +>a10 : (...x: Base[]) => Base +>x : Base[] +>Base : Base +>Base : Base + + var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base; +>a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base +>x : { foo: string; } +>foo : string +>y : { foo: string; bar: string; } +>foo : string +>bar : string +>Base : Base + + var a12: (x: Array, y: Array) => Array; +>a12 : (x: Base[], y: Derived2[]) => Derived[] +>x : Base[] +>Array : T[] +>Base : Base +>y : Derived2[] +>Array : T[] +>Derived2 : Derived2 +>Array : T[] +>Derived : Derived + + var a14: { +>a14 : { (x: number): number[]; (x: string): string[]; } + + (x: number): number[]; +>x : number + + (x: string): string[]; +>x : string + + }; + var a15: (x: { a: string; b: number }) => number; +>a15 : (x: { a: string; b: number; }) => number +>x : { a: string; b: number; } +>a : string +>b : number + + var a16: { +>a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; } + + (x: { +>x : { (a: number): number; (a?: number): number; } + + (a: number): number; +>a : number + + (a?: number): number; +>a : number + + }): number[]; + (x: { +>x : { (a: boolean): boolean; (a?: boolean): boolean; } + + (a: boolean): boolean; +>a : boolean + + (a?: boolean): boolean; +>a : boolean + + }): boolean[]; + }; + var a17: { +>a17 : { (x: { (a: T): T; (a: T): T; }): any[]; (x: { (a: T): T; (a: T): T; }): any[]; } + + (x: { +>x : { (a: T): T; (a: T): T; } + + (a: T): T; +>T : T +>Derived : Derived +>a : T +>T : T +>T : T + + (a: T): T; +>T : T +>Base : Base +>a : T +>T : T +>T : T + + }): any[]; + (x: { +>x : { (a: T): T; (a: T): T; } + + (a: T): T; +>T : T +>Derived2 : Derived2 +>a : T +>T : T +>T : T + + (a: T): T; +>T : T +>Base : Base +>a : T +>T : T +>T : T + + }): any[]; + }; + + var b2: (x: T) => U[]; +>b2 : (x: T) => U[] +>T : T +>U : U +>x : T +>T : T +>U : U + + a2 = b2; +>a2 = b2 : (x: T) => U[] +>a2 : (x: number) => string[] +>b2 : (x: T) => U[] + + b2 = a2; +>b2 = a2 : (x: number) => string[] +>b2 : (x: T) => U[] +>a2 : (x: number) => string[] + + var b7: (x: (arg: T) => U) => (r: T) => V; +>b7 : (x: (arg: T) => U) => (r: T) => V +>T : T +>Base : Base +>U : U +>Derived : Derived +>V : V +>Derived2 : Derived2 +>x : (arg: T) => U +>arg : T +>T : T +>U : U +>r : T +>T : T +>V : V + + a7 = b7; +>a7 = b7 : (x: (arg: T) => U) => (r: T) => V +>a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived2 +>b7 : (x: (arg: T) => U) => (r: T) => V + + b7 = a7; +>b7 = a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived2 +>b7 : (x: (arg: T) => U) => (r: T) => V +>a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived2 + + var b8: (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; +>b8 : (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U +>T : T +>Base : Base +>U : U +>Derived : Derived +>x : (arg: T) => U +>arg : T +>T : T +>U : U +>y : (arg2: { foo: number; }) => U +>arg2 : { foo: number; } +>foo : number +>U : U +>r : T +>T : T +>U : U + + a8 = b8; // error, { foo: number } and Base are incompatible +>a8 = b8 : (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U +>a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived +>b8 : (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U + + b8 = a8; // error, { foo: number } and Base are incompatible +>b8 = a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived +>b8 : (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U +>a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived + + + var b10: (...x: T[]) => T; +>b10 : (...x: T[]) => T +>T : T +>Derived : Derived +>x : T[] +>T : T +>T : T + + a10 = b10; +>a10 = b10 : (...x: T[]) => T +>a10 : (...x: Base[]) => Base +>b10 : (...x: T[]) => T + + b10 = a10; +>b10 = a10 : (...x: Base[]) => Base +>b10 : (...x: T[]) => T +>a10 : (...x: Base[]) => Base + + var b11: (x: T, y: T) => T; +>b11 : (x: T, y: T) => T +>T : T +>Derived : Derived +>x : T +>T : T +>y : T +>T : T +>T : T + + a11 = b11; +>a11 = b11 : (x: T, y: T) => T +>a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base +>b11 : (x: T, y: T) => T + + b11 = a11; +>b11 = a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base +>b11 : (x: T, y: T) => T +>a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base + + var b12: >(x: Array, y: Array) => T; +>b12 : (x: Base[], y: Base[]) => T +>T : T +>Array : T[] +>Derived2 : Derived2 +>x : Base[] +>Array : T[] +>Base : Base +>y : Base[] +>Array : T[] +>Base : Base +>T : T + + a12 = b12; +>a12 = b12 : (x: Base[], y: Base[]) => T +>a12 : (x: Base[], y: Derived2[]) => Derived[] +>b12 : (x: Base[], y: Base[]) => T + + b12 = a12; +>b12 = a12 : (x: Base[], y: Derived2[]) => Derived[] +>b12 : (x: Base[], y: Base[]) => T +>a12 : (x: Base[], y: Derived2[]) => Derived[] + + var b15: (x: { a: T; b: T }) => T; +>b15 : (x: { a: T; b: T; }) => T +>T : T +>x : { a: T; b: T; } +>a : T +>T : T +>b : T +>T : T +>T : T + + a15 = b15; +>a15 = b15 : (x: { a: T; b: T; }) => T +>a15 : (x: { a: string; b: number; }) => number +>b15 : (x: { a: T; b: T; }) => T + + b15 = a15; +>b15 = a15 : (x: { a: string; b: number; }) => number +>b15 : (x: { a: T; b: T; }) => T +>a15 : (x: { a: string; b: number; }) => number + + var b15a: (x: { a: T; b: T }) => number; +>b15a : (x: { a: T; b: T; }) => number +>T : T +>Base : Base +>x : { a: T; b: T; } +>a : T +>T : T +>b : T +>T : T + + a15 = b15a; +>a15 = b15a : (x: { a: T; b: T; }) => number +>a15 : (x: { a: string; b: number; }) => number +>b15a : (x: { a: T; b: T; }) => number + + b15a = a15; +>b15a = a15 : (x: { a: string; b: number; }) => number +>b15a : (x: { a: T; b: T; }) => number +>a15 : (x: { a: string; b: number; }) => number + + var b16: (x: (a: T) => T) => T[]; +>b16 : (x: (a: T) => T) => T[] +>T : T +>x : (a: T) => T +>a : T +>T : T +>T : T +>T : T + + a16 = b16; +>a16 = b16 : (x: (a: T) => T) => T[] +>a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; } +>b16 : (x: (a: T) => T) => T[] + + b16 = a16; +>b16 = a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; } +>b16 : (x: (a: T) => T) => T[] +>a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; } + + var b17: (x: (a: T) => T) => any[]; +>b17 : (x: (a: T) => T) => any[] +>T : T +>x : (a: T) => T +>a : T +>T : T +>T : T + + a17 = b17; +>a17 = b17 : (x: (a: T) => T) => any[] +>a17 : { (x: { (a: T): T; (a: T): T; }): any[]; (x: { (a: T): T; (a: T): T; }): any[]; } +>b17 : (x: (a: T) => T) => any[] + + b17 = a17; +>b17 = a17 : { (x: { (a: T): T; (a: T): T; }): any[]; (x: { (a: T): T; (a: T): T; }): any[]; } +>b17 : (x: (a: T) => T) => any[] +>a17 : { (x: { (a: T): T; (a: T): T; }): any[]; (x: { (a: T): T; (a: T): T; }): any[]; } + } + + module WithGenericSignaturesInBaseType { +>WithGenericSignaturesInBaseType : typeof WithGenericSignaturesInBaseType + + // target type has generic call signature + var a2: (x: T) => T[]; +>a2 : (x: T) => T[] +>T : T +>x : T +>T : T +>T : T + + var b2: (x: T) => string[]; +>b2 : (x: T) => string[] +>T : T +>x : T +>T : T + + a2 = b2; +>a2 = b2 : (x: T) => string[] +>a2 : (x: T) => T[] +>b2 : (x: T) => string[] + + b2 = a2; +>b2 = a2 : (x: T) => T[] +>b2 : (x: T) => string[] +>a2 : (x: T) => T[] + + // target type has generic call signature + var a3: (x: T) => string[]; +>a3 : (x: T) => string[] +>T : T +>x : T +>T : T + + var b3: (x: T) => T[]; +>b3 : (x: T) => T[] +>T : T +>x : T +>T : T +>T : T + + a3 = b3; +>a3 = b3 : (x: T) => T[] +>a3 : (x: T) => string[] +>b3 : (x: T) => T[] + + b3 = a3; +>b3 = a3 : (x: T) => string[] +>b3 : (x: T) => T[] +>a3 : (x: T) => string[] + } +} diff --git a/tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.symbols b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.symbols new file mode 100644 index 00000000000..c2a10279efa --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.symbols @@ -0,0 +1,309 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignaturesWithOptionalParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the base type + +interface Base { +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 0, 0)) + + a: () => number; +>a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) + + a2: (x?: number) => number; +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 9)) + + a3: (x: number) => number; +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 9)) + + a4: (x: number, y?: number) => number; +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 19)) + + a5: (x?: number, y?: number) => number; +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 20)) + + a6: (x: number, y: number) => number; +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 8, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 8, 19)) +} +var b: Base; +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 0, 0)) + +var a: () => number; +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) + + a = () => 1 // ok, same number of required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) + + a = (x?: number) => 1; // ok, same number of required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 14, 9)) + + a = (x: number) => 1; // error, too many required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 15, 9)) + + a = b.a; // ok +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) + + a = b.a2; // ok +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) + + a = b.a3; // error +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) + + a = b.a4; // error +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) + + a = b.a5; // ok +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) + + a = b.a6; // error +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) + +var a2: (x?: number) => number; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 9)) + + a2 = () => 1; // ok, same number of required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) + + a2 = (x?: number) => 1; // ok, same number of required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 25, 10)) + + a2 = (x: number) => 1; // ok, same number of params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 26, 10)) + + a2 = b.a; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) + + a2 = b.a2; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) + + a2 = b.a3; // ok, same number of params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) + + a2 = b.a4; // ok, excess params are optional in b.a3 +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) + + a2 = b.a5; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) + + a2 = b.a6; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 23, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) + +var a3: (x: number) => number; +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 9)) + + a3 = () => 1; // ok, fewer required params +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) + + a3 = (x?: number) => 1; // ok, fewer required params +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 36, 10)) + + a3 = (x: number) => 1; // ok, same number of required params +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 37, 10)) + + a3 = (x: number, y: number) => 1; // error, too many required params +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 38, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 38, 20)) + + a3 = b.a; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) + + a3 = b.a2; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) + + a3 = b.a3; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) + + a3 = b.a4; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) + + a3 = b.a5; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) + + a3 = b.a6; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 34, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) + +var a4: (x: number, y?: number) => number; +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 19)) + + a4 = () => 1; // ok, fewer required params +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) + + a4 = (x?: number, y?: number) => 1; // ok, fewer required params +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 48, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 48, 21)) + + a4 = (x: number) => 1; // ok, same number of required params +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 49, 10)) + + a4 = (x: number, y: number) => 1; // ok, same number of params +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 50, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 50, 20)) + + a4 = b.a; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) + + a4 = b.a2; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) + + a4 = b.a3; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) + + a4 = b.a4; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) + + a4 = b.a5; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) + + a4 = b.a6; // ok, same number of params +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 46, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) + +var a5: (x?: number, y?: number) => number; +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 20)) + + a5 = () => 1; // ok, fewer required params +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) + + a5 = (x?: number, y?: number) => 1; // ok, fewer required params +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 60, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 60, 21)) + + a5 = (x: number) => 1; // ok, fewer params in lambda +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 61, 10)) + + a5 = (x: number, y: number) => 1; // ok, same number of params +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 62, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 62, 20)) + + a5 = b.a; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 2, 16)) + + a5 = b.a2; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 3, 20)) + + a5 = b.a3; // ok, fewer params in b.a3 +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 4, 31)) + + a5 = b.a4; // ok, same number of params +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 5, 30)) + + a5 = b.a5; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 6, 42)) + + a5 = b.a6; // ok, same number of params +>a5 : Symbol(a5, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 58, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) +>b : Symbol(b, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithCallSignaturesWithOptionalParameters.ts, 7, 43)) + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.types b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.types new file mode 100644 index 00000000000..1bb87d3255f --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.types @@ -0,0 +1,393 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignaturesWithOptionalParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the base type + +interface Base { +>Base : Base + + a: () => number; +>a : () => number + + a2: (x?: number) => number; +>a2 : (x?: number) => number +>x : number + + a3: (x: number) => number; +>a3 : (x: number) => number +>x : number + + a4: (x: number, y?: number) => number; +>a4 : (x: number, y?: number) => number +>x : number +>y : number + + a5: (x?: number, y?: number) => number; +>a5 : (x?: number, y?: number) => number +>x : number +>y : number + + a6: (x: number, y: number) => number; +>a6 : (x: number, y: number) => number +>x : number +>y : number +} +var b: Base; +>b : Base +>Base : Base + +var a: () => number; +>a : () => number + + a = () => 1 // ok, same number of required params +>a = () => 1 : () => number +>a : () => number +>() => 1 : () => number +>1 : 1 + + a = (x?: number) => 1; // ok, same number of required params +>a = (x?: number) => 1 : (x?: number) => number +>a : () => number +>(x?: number) => 1 : (x?: number) => number +>x : number +>1 : 1 + + a = (x: number) => 1; // error, too many required params +>a = (x: number) => 1 : (x: number) => number +>a : () => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a = b.a; // ok +>a = b.a : () => number +>a : () => number +>b.a : () => number +>b : Base +>a : () => number + + a = b.a2; // ok +>a = b.a2 : (x?: number) => number +>a : () => number +>b.a2 : (x?: number) => number +>b : Base +>a2 : (x?: number) => number + + a = b.a3; // error +>a = b.a3 : (x: number) => number +>a : () => number +>b.a3 : (x: number) => number +>b : Base +>a3 : (x: number) => number + + a = b.a4; // error +>a = b.a4 : (x: number, y?: number) => number +>a : () => number +>b.a4 : (x: number, y?: number) => number +>b : Base +>a4 : (x: number, y?: number) => number + + a = b.a5; // ok +>a = b.a5 : (x?: number, y?: number) => number +>a : () => number +>b.a5 : (x?: number, y?: number) => number +>b : Base +>a5 : (x?: number, y?: number) => number + + a = b.a6; // error +>a = b.a6 : (x: number, y: number) => number +>a : () => number +>b.a6 : (x: number, y: number) => number +>b : Base +>a6 : (x: number, y: number) => number + +var a2: (x?: number) => number; +>a2 : (x?: number) => number +>x : number + + a2 = () => 1; // ok, same number of required params +>a2 = () => 1 : () => number +>a2 : (x?: number) => number +>() => 1 : () => number +>1 : 1 + + a2 = (x?: number) => 1; // ok, same number of required params +>a2 = (x?: number) => 1 : (x?: number) => number +>a2 : (x?: number) => number +>(x?: number) => 1 : (x?: number) => number +>x : number +>1 : 1 + + a2 = (x: number) => 1; // ok, same number of params +>a2 = (x: number) => 1 : (x: number) => number +>a2 : (x?: number) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a2 = b.a; // ok +>a2 = b.a : () => number +>a2 : (x?: number) => number +>b.a : () => number +>b : Base +>a : () => number + + a2 = b.a2; // ok +>a2 = b.a2 : (x?: number) => number +>a2 : (x?: number) => number +>b.a2 : (x?: number) => number +>b : Base +>a2 : (x?: number) => number + + a2 = b.a3; // ok, same number of params +>a2 = b.a3 : (x: number) => number +>a2 : (x?: number) => number +>b.a3 : (x: number) => number +>b : Base +>a3 : (x: number) => number + + a2 = b.a4; // ok, excess params are optional in b.a3 +>a2 = b.a4 : (x: number, y?: number) => number +>a2 : (x?: number) => number +>b.a4 : (x: number, y?: number) => number +>b : Base +>a4 : (x: number, y?: number) => number + + a2 = b.a5; // ok +>a2 = b.a5 : (x?: number, y?: number) => number +>a2 : (x?: number) => number +>b.a5 : (x?: number, y?: number) => number +>b : Base +>a5 : (x?: number, y?: number) => number + + a2 = b.a6; // error +>a2 = b.a6 : (x: number, y: number) => number +>a2 : (x?: number) => number +>b.a6 : (x: number, y: number) => number +>b : Base +>a6 : (x: number, y: number) => number + +var a3: (x: number) => number; +>a3 : (x: number) => number +>x : number + + a3 = () => 1; // ok, fewer required params +>a3 = () => 1 : () => number +>a3 : (x: number) => number +>() => 1 : () => number +>1 : 1 + + a3 = (x?: number) => 1; // ok, fewer required params +>a3 = (x?: number) => 1 : (x?: number) => number +>a3 : (x: number) => number +>(x?: number) => 1 : (x?: number) => number +>x : number +>1 : 1 + + a3 = (x: number) => 1; // ok, same number of required params +>a3 = (x: number) => 1 : (x: number) => number +>a3 : (x: number) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a3 = (x: number, y: number) => 1; // error, too many required params +>a3 = (x: number, y: number) => 1 : (x: number, y: number) => number +>a3 : (x: number) => number +>(x: number, y: number) => 1 : (x: number, y: number) => number +>x : number +>y : number +>1 : 1 + + a3 = b.a; // ok +>a3 = b.a : () => number +>a3 : (x: number) => number +>b.a : () => number +>b : Base +>a : () => number + + a3 = b.a2; // ok +>a3 = b.a2 : (x?: number) => number +>a3 : (x: number) => number +>b.a2 : (x?: number) => number +>b : Base +>a2 : (x?: number) => number + + a3 = b.a3; // ok +>a3 = b.a3 : (x: number) => number +>a3 : (x: number) => number +>b.a3 : (x: number) => number +>b : Base +>a3 : (x: number) => number + + a3 = b.a4; // ok +>a3 = b.a4 : (x: number, y?: number) => number +>a3 : (x: number) => number +>b.a4 : (x: number, y?: number) => number +>b : Base +>a4 : (x: number, y?: number) => number + + a3 = b.a5; // ok +>a3 = b.a5 : (x?: number, y?: number) => number +>a3 : (x: number) => number +>b.a5 : (x?: number, y?: number) => number +>b : Base +>a5 : (x?: number, y?: number) => number + + a3 = b.a6; // error +>a3 = b.a6 : (x: number, y: number) => number +>a3 : (x: number) => number +>b.a6 : (x: number, y: number) => number +>b : Base +>a6 : (x: number, y: number) => number + +var a4: (x: number, y?: number) => number; +>a4 : (x: number, y?: number) => number +>x : number +>y : number + + a4 = () => 1; // ok, fewer required params +>a4 = () => 1 : () => number +>a4 : (x: number, y?: number) => number +>() => 1 : () => number +>1 : 1 + + a4 = (x?: number, y?: number) => 1; // ok, fewer required params +>a4 = (x?: number, y?: number) => 1 : (x?: number, y?: number) => number +>a4 : (x: number, y?: number) => number +>(x?: number, y?: number) => 1 : (x?: number, y?: number) => number +>x : number +>y : number +>1 : 1 + + a4 = (x: number) => 1; // ok, same number of required params +>a4 = (x: number) => 1 : (x: number) => number +>a4 : (x: number, y?: number) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a4 = (x: number, y: number) => 1; // ok, same number of params +>a4 = (x: number, y: number) => 1 : (x: number, y: number) => number +>a4 : (x: number, y?: number) => number +>(x: number, y: number) => 1 : (x: number, y: number) => number +>x : number +>y : number +>1 : 1 + + a4 = b.a; // ok +>a4 = b.a : () => number +>a4 : (x: number, y?: number) => number +>b.a : () => number +>b : Base +>a : () => number + + a4 = b.a2; // ok +>a4 = b.a2 : (x?: number) => number +>a4 : (x: number, y?: number) => number +>b.a2 : (x?: number) => number +>b : Base +>a2 : (x?: number) => number + + a4 = b.a3; // ok +>a4 = b.a3 : (x: number) => number +>a4 : (x: number, y?: number) => number +>b.a3 : (x: number) => number +>b : Base +>a3 : (x: number) => number + + a4 = b.a4; // ok +>a4 = b.a4 : (x: number, y?: number) => number +>a4 : (x: number, y?: number) => number +>b.a4 : (x: number, y?: number) => number +>b : Base +>a4 : (x: number, y?: number) => number + + a4 = b.a5; // ok +>a4 = b.a5 : (x?: number, y?: number) => number +>a4 : (x: number, y?: number) => number +>b.a5 : (x?: number, y?: number) => number +>b : Base +>a5 : (x?: number, y?: number) => number + + a4 = b.a6; // ok, same number of params +>a4 = b.a6 : (x: number, y: number) => number +>a4 : (x: number, y?: number) => number +>b.a6 : (x: number, y: number) => number +>b : Base +>a6 : (x: number, y: number) => number + +var a5: (x?: number, y?: number) => number; +>a5 : (x?: number, y?: number) => number +>x : number +>y : number + + a5 = () => 1; // ok, fewer required params +>a5 = () => 1 : () => number +>a5 : (x?: number, y?: number) => number +>() => 1 : () => number +>1 : 1 + + a5 = (x?: number, y?: number) => 1; // ok, fewer required params +>a5 = (x?: number, y?: number) => 1 : (x?: number, y?: number) => number +>a5 : (x?: number, y?: number) => number +>(x?: number, y?: number) => 1 : (x?: number, y?: number) => number +>x : number +>y : number +>1 : 1 + + a5 = (x: number) => 1; // ok, fewer params in lambda +>a5 = (x: number) => 1 : (x: number) => number +>a5 : (x?: number, y?: number) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a5 = (x: number, y: number) => 1; // ok, same number of params +>a5 = (x: number, y: number) => 1 : (x: number, y: number) => number +>a5 : (x?: number, y?: number) => number +>(x: number, y: number) => 1 : (x: number, y: number) => number +>x : number +>y : number +>1 : 1 + + a5 = b.a; // ok +>a5 = b.a : () => number +>a5 : (x?: number, y?: number) => number +>b.a : () => number +>b : Base +>a : () => number + + a5 = b.a2; // ok +>a5 = b.a2 : (x?: number) => number +>a5 : (x?: number, y?: number) => number +>b.a2 : (x?: number) => number +>b : Base +>a2 : (x?: number) => number + + a5 = b.a3; // ok, fewer params in b.a3 +>a5 = b.a3 : (x: number) => number +>a5 : (x?: number, y?: number) => number +>b.a3 : (x: number) => number +>b : Base +>a3 : (x: number) => number + + a5 = b.a4; // ok, same number of params +>a5 = b.a4 : (x: number, y?: number) => number +>a5 : (x?: number, y?: number) => number +>b.a4 : (x: number, y?: number) => number +>b : Base +>a4 : (x: number, y?: number) => number + + a5 = b.a5; // ok +>a5 = b.a5 : (x?: number, y?: number) => number +>a5 : (x?: number, y?: number) => number +>b.a5 : (x?: number, y?: number) => number +>b : Base +>a5 : (x?: number, y?: number) => number + + a5 = b.a6; // ok, same number of params +>a5 = b.a6 : (x: number, y: number) => number +>a5 : (x?: number, y?: number) => number +>b.a6 : (x: number, y: number) => number +>b : Base +>a6 : (x: number, y: number) => number + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.symbols b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.symbols new file mode 100644 index 00000000000..f38ad64d13d --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.symbols @@ -0,0 +1,174 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignaturesWithRestParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the target for assignment + +interface Base { +>Base : Symbol(Base, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 0, 0)) + + a: (...args: number[]) => number; +>a : Symbol(Base.a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 2, 16)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 3, 8)) + + a2: (x: number, ...z: number[]) => number; +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 3, 37)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 4, 9)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 4, 19)) + + a3: (x: number, y?: string, ...z: number[]) => number; +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 4, 46)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 5, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 5, 19)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 5, 31)) + + a4: (x?: number, y?: string, ...z: number[]) => number; +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 5, 58)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 6, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 6, 20)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 6, 32)) +} + +var a: (...args: number[]) => number; // ok, same number of required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 8)) + + a = () => 1; // ok, same number of required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) + + a = (...args: number[]) => 1; // ok, same number of required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 11, 9)) + + a = (...args: string[]) => 1; // error, type mismatch +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 12, 9)) + + a = (x?: number) => 1; // ok, same number of required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 13, 9)) + + a = (x?: number, y?: number, z?: number) => 1; // ok, same number of required params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 14, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 14, 20)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 14, 32)) + + a = (x: number) => 1; // ok, rest param corresponds to infinite number of params +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 15, 9)) + + a = (x?: string) => 1; // error, incompatible type +>a : Symbol(a, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 9, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 16, 9)) + + +var a2: (x: number, ...z: number[]) => number; +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 9)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 19)) + + a2 = () => 1; // ok, fewer required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) + + a2 = (...args: number[]) => 1; // ok, fewer required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 21, 10)) + + a2 = (x?: number) => 1; // ok, fewer required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 22, 10)) + + a2 = (x: number) => 1; // ok, same number of required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 23, 10)) + + a2 = (x: number, ...args: number[]) => 1; // ok, same number of required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 24, 10)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 24, 20)) + + a2 = (x: number, ...args: string[]) => 1; // should be type mismatch error +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 25, 10)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 25, 20)) + + a2 = (x: number, y: number) => 1; // ok, rest param corresponds to infinite number of params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 26, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 26, 20)) + + a2 = (x: number, y?: number) => 1; // ok, same number of required params +>a2 : Symbol(a2, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 19, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 27, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 27, 20)) + +var a3: (x: number, y?: string, ...z: number[]) => number; +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 19)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 31)) + + a3 = () => 1; // ok, fewer required params +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) + + a3 = (x?: number) => 1; // ok, fewer required params +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 31, 10)) + + a3 = (x: number) => 1; // ok, same number of required params +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 32, 10)) + + a3 = (x: number, y: string) => 1; // ok, all present params match +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 33, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 33, 20)) + + a3 = (x: number, y?: number, z?: number) => 1; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 34, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 34, 20)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 34, 32)) + + a3 = (x: number, ...z: number[]) => 1; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 35, 10)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 35, 20)) + + a3 = (x: string, y?: string, z?: string) => 1; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 29, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 36, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 36, 20)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 36, 32)) + +var a4: (x?: number, y?: string, ...z: number[]) => number; +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 9)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 20)) +>z : Symbol(z, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 32)) + + a4 = () => 1; // ok, fewer required params +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 3)) + + a4 = (x?: number, y?: number) => 1; // error, type mismatch +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 40, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 40, 21)) + + a4 = (x: number) => 1; // ok, all present params match +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 41, 10)) + + a4 = (x: number, y?: number) => 1; // error, second param has type mismatch +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 42, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 42, 20)) + + a4 = (x?: number, y?: string) => 1; // ok, same number of required params with matching types +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 43, 10)) +>y : Symbol(y, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 43, 21)) + + a4 = (x: number, ...args: string[]) => 1; // error, rest params have type mismatch +>a4 : Symbol(a4, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 38, 3)) +>x : Symbol(x, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 44, 10)) +>args : Symbol(args, Decl(assignmentCompatWithCallSignaturesWithRestParameters.ts, 44, 20)) + diff --git a/tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.types b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.types new file mode 100644 index 00000000000..a2c726527cb --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.types @@ -0,0 +1,258 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignaturesWithRestParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the target for assignment + +interface Base { +>Base : Base + + a: (...args: number[]) => number; +>a : (...args: number[]) => number +>args : number[] + + a2: (x: number, ...z: number[]) => number; +>a2 : (x: number, ...z: number[]) => number +>x : number +>z : number[] + + a3: (x: number, y?: string, ...z: number[]) => number; +>a3 : (x: number, y?: string, ...z: number[]) => number +>x : number +>y : string +>z : number[] + + a4: (x?: number, y?: string, ...z: number[]) => number; +>a4 : (x?: number, y?: string, ...z: number[]) => number +>x : number +>y : string +>z : number[] +} + +var a: (...args: number[]) => number; // ok, same number of required params +>a : (...args: number[]) => number +>args : number[] + + a = () => 1; // ok, same number of required params +>a = () => 1 : () => number +>a : (...args: number[]) => number +>() => 1 : () => number +>1 : 1 + + a = (...args: number[]) => 1; // ok, same number of required params +>a = (...args: number[]) => 1 : (...args: number[]) => number +>a : (...args: number[]) => number +>(...args: number[]) => 1 : (...args: number[]) => number +>args : number[] +>1 : 1 + + a = (...args: string[]) => 1; // error, type mismatch +>a = (...args: string[]) => 1 : (...args: string[]) => number +>a : (...args: number[]) => number +>(...args: string[]) => 1 : (...args: string[]) => number +>args : string[] +>1 : 1 + + a = (x?: number) => 1; // ok, same number of required params +>a = (x?: number) => 1 : (x?: number) => number +>a : (...args: number[]) => number +>(x?: number) => 1 : (x?: number) => number +>x : number +>1 : 1 + + a = (x?: number, y?: number, z?: number) => 1; // ok, same number of required params +>a = (x?: number, y?: number, z?: number) => 1 : (x?: number, y?: number, z?: number) => number +>a : (...args: number[]) => number +>(x?: number, y?: number, z?: number) => 1 : (x?: number, y?: number, z?: number) => number +>x : number +>y : number +>z : number +>1 : 1 + + a = (x: number) => 1; // ok, rest param corresponds to infinite number of params +>a = (x: number) => 1 : (x: number) => number +>a : (...args: number[]) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a = (x?: string) => 1; // error, incompatible type +>a = (x?: string) => 1 : (x?: string) => number +>a : (...args: number[]) => number +>(x?: string) => 1 : (x?: string) => number +>x : string +>1 : 1 + + +var a2: (x: number, ...z: number[]) => number; +>a2 : (x: number, ...z: number[]) => number +>x : number +>z : number[] + + a2 = () => 1; // ok, fewer required params +>a2 = () => 1 : () => number +>a2 : (x: number, ...z: number[]) => number +>() => 1 : () => number +>1 : 1 + + a2 = (...args: number[]) => 1; // ok, fewer required params +>a2 = (...args: number[]) => 1 : (...args: number[]) => number +>a2 : (x: number, ...z: number[]) => number +>(...args: number[]) => 1 : (...args: number[]) => number +>args : number[] +>1 : 1 + + a2 = (x?: number) => 1; // ok, fewer required params +>a2 = (x?: number) => 1 : (x?: number) => number +>a2 : (x: number, ...z: number[]) => number +>(x?: number) => 1 : (x?: number) => number +>x : number +>1 : 1 + + a2 = (x: number) => 1; // ok, same number of required params +>a2 = (x: number) => 1 : (x: number) => number +>a2 : (x: number, ...z: number[]) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a2 = (x: number, ...args: number[]) => 1; // ok, same number of required params +>a2 = (x: number, ...args: number[]) => 1 : (x: number, ...args: number[]) => number +>a2 : (x: number, ...z: number[]) => number +>(x: number, ...args: number[]) => 1 : (x: number, ...args: number[]) => number +>x : number +>args : number[] +>1 : 1 + + a2 = (x: number, ...args: string[]) => 1; // should be type mismatch error +>a2 = (x: number, ...args: string[]) => 1 : (x: number, ...args: string[]) => number +>a2 : (x: number, ...z: number[]) => number +>(x: number, ...args: string[]) => 1 : (x: number, ...args: string[]) => number +>x : number +>args : string[] +>1 : 1 + + a2 = (x: number, y: number) => 1; // ok, rest param corresponds to infinite number of params +>a2 = (x: number, y: number) => 1 : (x: number, y: number) => number +>a2 : (x: number, ...z: number[]) => number +>(x: number, y: number) => 1 : (x: number, y: number) => number +>x : number +>y : number +>1 : 1 + + a2 = (x: number, y?: number) => 1; // ok, same number of required params +>a2 = (x: number, y?: number) => 1 : (x: number, y?: number) => number +>a2 : (x: number, ...z: number[]) => number +>(x: number, y?: number) => 1 : (x: number, y?: number) => number +>x : number +>y : number +>1 : 1 + +var a3: (x: number, y?: string, ...z: number[]) => number; +>a3 : (x: number, y?: string, ...z: number[]) => number +>x : number +>y : string +>z : number[] + + a3 = () => 1; // ok, fewer required params +>a3 = () => 1 : () => number +>a3 : (x: number, y?: string, ...z: number[]) => number +>() => 1 : () => number +>1 : 1 + + a3 = (x?: number) => 1; // ok, fewer required params +>a3 = (x?: number) => 1 : (x?: number) => number +>a3 : (x: number, y?: string, ...z: number[]) => number +>(x?: number) => 1 : (x?: number) => number +>x : number +>1 : 1 + + a3 = (x: number) => 1; // ok, same number of required params +>a3 = (x: number) => 1 : (x: number) => number +>a3 : (x: number, y?: string, ...z: number[]) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a3 = (x: number, y: string) => 1; // ok, all present params match +>a3 = (x: number, y: string) => 1 : (x: number, y: string) => number +>a3 : (x: number, y?: string, ...z: number[]) => number +>(x: number, y: string) => 1 : (x: number, y: string) => number +>x : number +>y : string +>1 : 1 + + a3 = (x: number, y?: number, z?: number) => 1; // error +>a3 = (x: number, y?: number, z?: number) => 1 : (x: number, y?: number, z?: number) => number +>a3 : (x: number, y?: string, ...z: number[]) => number +>(x: number, y?: number, z?: number) => 1 : (x: number, y?: number, z?: number) => number +>x : number +>y : number +>z : number +>1 : 1 + + a3 = (x: number, ...z: number[]) => 1; // error +>a3 = (x: number, ...z: number[]) => 1 : (x: number, ...z: number[]) => number +>a3 : (x: number, y?: string, ...z: number[]) => number +>(x: number, ...z: number[]) => 1 : (x: number, ...z: number[]) => number +>x : number +>z : number[] +>1 : 1 + + a3 = (x: string, y?: string, z?: string) => 1; // error +>a3 = (x: string, y?: string, z?: string) => 1 : (x: string, y?: string, z?: string) => number +>a3 : (x: number, y?: string, ...z: number[]) => number +>(x: string, y?: string, z?: string) => 1 : (x: string, y?: string, z?: string) => number +>x : string +>y : string +>z : string +>1 : 1 + +var a4: (x?: number, y?: string, ...z: number[]) => number; +>a4 : (x?: number, y?: string, ...z: number[]) => number +>x : number +>y : string +>z : number[] + + a4 = () => 1; // ok, fewer required params +>a4 = () => 1 : () => number +>a4 : (x?: number, y?: string, ...z: number[]) => number +>() => 1 : () => number +>1 : 1 + + a4 = (x?: number, y?: number) => 1; // error, type mismatch +>a4 = (x?: number, y?: number) => 1 : (x?: number, y?: number) => number +>a4 : (x?: number, y?: string, ...z: number[]) => number +>(x?: number, y?: number) => 1 : (x?: number, y?: number) => number +>x : number +>y : number +>1 : 1 + + a4 = (x: number) => 1; // ok, all present params match +>a4 = (x: number) => 1 : (x: number) => number +>a4 : (x?: number, y?: string, ...z: number[]) => number +>(x: number) => 1 : (x: number) => number +>x : number +>1 : 1 + + a4 = (x: number, y?: number) => 1; // error, second param has type mismatch +>a4 = (x: number, y?: number) => 1 : (x: number, y?: number) => number +>a4 : (x?: number, y?: string, ...z: number[]) => number +>(x: number, y?: number) => 1 : (x: number, y?: number) => number +>x : number +>y : number +>1 : 1 + + a4 = (x?: number, y?: string) => 1; // ok, same number of required params with matching types +>a4 = (x?: number, y?: string) => 1 : (x?: number, y?: string) => number +>a4 : (x?: number, y?: string, ...z: number[]) => number +>(x?: number, y?: string) => 1 : (x?: number, y?: string) => number +>x : number +>y : string +>1 : 1 + + a4 = (x: number, ...args: string[]) => 1; // error, rest params have type mismatch +>a4 = (x: number, ...args: string[]) => 1 : (x: number, ...args: string[]) => number +>a4 : (x?: number, y?: string, ...z: number[]) => number +>(x: number, ...args: string[]) => 1 : (x: number, ...args: string[]) => number +>x : number +>args : string[] +>1 : 1 + diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures.symbols b/tests/baselines/reference/assignmentCompatWithConstructSignatures.symbols new file mode 100644 index 00000000000..78c153212b8 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures.symbols @@ -0,0 +1,102 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignatures.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures.ts, 0, 0)) + + new (x: number): void; +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 3, 9)) +} +var t: T; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures.ts, 0, 0)) + +var a: { new (x: number): void }; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 6, 14)) + +t = a; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) + +a = t; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) + +interface S { +>S : Symbol(S, Decl(assignmentCompatWithConstructSignatures.ts, 9, 6)) + + new (x: number): string; +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 12, 9)) +} +var s: S; +>s : Symbol(s, Decl(assignmentCompatWithConstructSignatures.ts, 14, 3)) +>S : Symbol(S, Decl(assignmentCompatWithConstructSignatures.ts, 9, 6)) + +var a2: { new (x: number): string }; +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures.ts, 15, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 15, 15)) + +t = s; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>s : Symbol(s, Decl(assignmentCompatWithConstructSignatures.ts, 14, 3)) + +t = a2; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures.ts, 15, 3)) + +a = s; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>s : Symbol(s, Decl(assignmentCompatWithConstructSignatures.ts, 14, 3)) + +a = a2; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures.ts, 15, 3)) + +interface S2 { +>S2 : Symbol(S2, Decl(assignmentCompatWithConstructSignatures.ts, 19, 7)) + + (x: string): void; +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 22, 5)) +} +var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithConstructSignatures.ts, 24, 3)) +>S2 : Symbol(S2, Decl(assignmentCompatWithConstructSignatures.ts, 19, 7)) + +var a3: { (x: string): void }; +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures.ts, 25, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 25, 11)) + +// these are errors +t = s2; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithConstructSignatures.ts, 24, 3)) + +t = a3; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures.ts, 25, 3)) + +t = (x: string) => 1; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 29, 5)) + +t = function (x: string) { return ''; } +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 30, 14)) + +a = s2; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithConstructSignatures.ts, 24, 3)) + +a = a3; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures.ts, 25, 3)) + +a = (x: string) => 1; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 33, 5)) + +a = function (x: string) { return ''; } +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures.ts, 34, 14)) + diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures.types b/tests/baselines/reference/assignmentCompatWithConstructSignatures.types new file mode 100644 index 00000000000..038988807e5 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures.types @@ -0,0 +1,124 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignatures.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : T + + new (x: number): void; +>x : number +} +var t: T; +>t : T +>T : T + +var a: { new (x: number): void }; +>a : new (x: number) => void +>x : number + +t = a; +>t = a : new (x: number) => void +>t : T +>a : new (x: number) => void + +a = t; +>a = t : T +>a : new (x: number) => void +>t : T + +interface S { +>S : S + + new (x: number): string; +>x : number +} +var s: S; +>s : S +>S : S + +var a2: { new (x: number): string }; +>a2 : new (x: number) => string +>x : number + +t = s; +>t = s : S +>t : T +>s : S + +t = a2; +>t = a2 : new (x: number) => string +>t : T +>a2 : new (x: number) => string + +a = s; +>a = s : S +>a : new (x: number) => void +>s : S + +a = a2; +>a = a2 : new (x: number) => string +>a : new (x: number) => void +>a2 : new (x: number) => string + +interface S2 { +>S2 : S2 + + (x: string): void; +>x : string +} +var s2: S2; +>s2 : S2 +>S2 : S2 + +var a3: { (x: string): void }; +>a3 : (x: string) => void +>x : string + +// these are errors +t = s2; +>t = s2 : S2 +>t : T +>s2 : S2 + +t = a3; +>t = a3 : (x: string) => void +>t : T +>a3 : (x: string) => void + +t = (x: string) => 1; +>t = (x: string) => 1 : (x: string) => number +>t : T +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +t = function (x: string) { return ''; } +>t = function (x: string) { return ''; } : (x: string) => string +>t : T +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + +a = s2; +>a = s2 : S2 +>a : new (x: number) => void +>s2 : S2 + +a = a3; +>a = a3 : (x: string) => void +>a : new (x: number) => void +>a3 : (x: string) => void + +a = (x: string) => 1; +>a = (x: string) => 1 : (x: string) => number +>a : new (x: number) => void +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +a = function (x: string) { return ''; } +>a = function (x: string) { return ''; } : (x: string) => string +>a : new (x: number) => void +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures2.symbols b/tests/baselines/reference/assignmentCompatWithConstructSignatures2.symbols new file mode 100644 index 00000000000..ed67a37896e --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures2.symbols @@ -0,0 +1,123 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignatures2.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures2.ts, 0, 0)) + + f: new (x: number) => void; +>f : Symbol(T.f, Decl(assignmentCompatWithConstructSignatures2.ts, 2, 13)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 3, 12)) +} +var t: T; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures2.ts, 0, 0)) + +var a: { f: new (x: number) => void }; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 8)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 17)) + +t = a; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) + +a = t; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) + +interface S { +>S : Symbol(S, Decl(assignmentCompatWithConstructSignatures2.ts, 9, 6)) + + f: new (x: number) => string; +>f : Symbol(S.f, Decl(assignmentCompatWithConstructSignatures2.ts, 11, 13)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 12, 12)) +} +var s: S; +>s : Symbol(s, Decl(assignmentCompatWithConstructSignatures2.ts, 14, 3)) +>S : Symbol(S, Decl(assignmentCompatWithConstructSignatures2.ts, 9, 6)) + +var a2: { f: new (x: number) => string }; +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures2.ts, 15, 3)) +>f : Symbol(f, Decl(assignmentCompatWithConstructSignatures2.ts, 15, 9)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 15, 18)) + +t = s; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>s : Symbol(s, Decl(assignmentCompatWithConstructSignatures2.ts, 14, 3)) + +t = a2; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures2.ts, 15, 3)) + +a = s; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>s : Symbol(s, Decl(assignmentCompatWithConstructSignatures2.ts, 14, 3)) + +a = a2; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures2.ts, 15, 3)) + +// errors +t = () => 1; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) + +t = function (x: number) { return ''; } +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 23, 14)) + +a = () => 1; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) + +a = function (x: number) { return ''; } +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 25, 14)) + +interface S2 { +>S2 : Symbol(S2, Decl(assignmentCompatWithConstructSignatures2.ts, 25, 39)) + + f(x: string): void; +>f : Symbol(S2.f, Decl(assignmentCompatWithConstructSignatures2.ts, 27, 14)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 28, 6)) +} +var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithConstructSignatures2.ts, 30, 3)) +>S2 : Symbol(S2, Decl(assignmentCompatWithConstructSignatures2.ts, 25, 39)) + +var a3: { f(x: string): void }; +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures2.ts, 31, 3)) +>f : Symbol(f, Decl(assignmentCompatWithConstructSignatures2.ts, 31, 9)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 31, 12)) + +// these are errors +t = s2; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithConstructSignatures2.ts, 30, 3)) + +t = a3; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures2.ts, 31, 3)) + +t = (x: string) => 1; +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 35, 5)) + +t = function (x: string) { return ''; } +>t : Symbol(t, Decl(assignmentCompatWithConstructSignatures2.ts, 5, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 36, 14)) + +a = s2; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>s2 : Symbol(s2, Decl(assignmentCompatWithConstructSignatures2.ts, 30, 3)) + +a = a3; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures2.ts, 31, 3)) + +a = (x: string) => 1; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 39, 5)) + +a = function (x: string) { return ''; } +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures2.ts, 6, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures2.ts, 40, 14)) + diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures2.types b/tests/baselines/reference/assignmentCompatWithConstructSignatures2.types new file mode 100644 index 00000000000..f797dcf83fa --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures2.types @@ -0,0 +1,157 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignatures2.ts === +// void returning call signatures can be assigned a non-void returning call signature that otherwise matches + +interface T { +>T : T + + f: new (x: number) => void; +>f : new (x: number) => void +>x : number +} +var t: T; +>t : T +>T : T + +var a: { f: new (x: number) => void }; +>a : { f: new (x: number) => void; } +>f : new (x: number) => void +>x : number + +t = a; +>t = a : { f: new (x: number) => void; } +>t : T +>a : { f: new (x: number) => void; } + +a = t; +>a = t : T +>a : { f: new (x: number) => void; } +>t : T + +interface S { +>S : S + + f: new (x: number) => string; +>f : new (x: number) => string +>x : number +} +var s: S; +>s : S +>S : S + +var a2: { f: new (x: number) => string }; +>a2 : { f: new (x: number) => string; } +>f : new (x: number) => string +>x : number + +t = s; +>t = s : S +>t : T +>s : S + +t = a2; +>t = a2 : { f: new (x: number) => string; } +>t : T +>a2 : { f: new (x: number) => string; } + +a = s; +>a = s : S +>a : { f: new (x: number) => void; } +>s : S + +a = a2; +>a = a2 : { f: new (x: number) => string; } +>a : { f: new (x: number) => void; } +>a2 : { f: new (x: number) => string; } + +// errors +t = () => 1; +>t = () => 1 : () => number +>t : T +>() => 1 : () => number +>1 : 1 + +t = function (x: number) { return ''; } +>t = function (x: number) { return ''; } : (x: number) => string +>t : T +>function (x: number) { return ''; } : (x: number) => string +>x : number +>'' : "" + +a = () => 1; +>a = () => 1 : () => number +>a : { f: new (x: number) => void; } +>() => 1 : () => number +>1 : 1 + +a = function (x: number) { return ''; } +>a = function (x: number) { return ''; } : (x: number) => string +>a : { f: new (x: number) => void; } +>function (x: number) { return ''; } : (x: number) => string +>x : number +>'' : "" + +interface S2 { +>S2 : S2 + + f(x: string): void; +>f : (x: string) => void +>x : string +} +var s2: S2; +>s2 : S2 +>S2 : S2 + +var a3: { f(x: string): void }; +>a3 : { f(x: string): void; } +>f : (x: string) => void +>x : string + +// these are errors +t = s2; +>t = s2 : S2 +>t : T +>s2 : S2 + +t = a3; +>t = a3 : { f(x: string): void; } +>t : T +>a3 : { f(x: string): void; } + +t = (x: string) => 1; +>t = (x: string) => 1 : (x: string) => number +>t : T +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +t = function (x: string) { return ''; } +>t = function (x: string) { return ''; } : (x: string) => string +>t : T +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + +a = s2; +>a = s2 : S2 +>a : { f: new (x: number) => void; } +>s2 : S2 + +a = a3; +>a = a3 : { f(x: string): void; } +>a : { f: new (x: number) => void; } +>a3 : { f(x: string): void; } + +a = (x: string) => 1; +>a = (x: string) => 1 : (x: string) => number +>a : { f: new (x: number) => void; } +>(x: string) => 1 : (x: string) => number +>x : string +>1 : 1 + +a = function (x: string) { return ''; } +>a = function (x: string) { return ''; } : (x: string) => string +>a : { f: new (x: number) => void; } +>function (x: string) { return ''; } : (x: string) => string +>x : string +>'' : "" + diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures4.symbols b/tests/baselines/reference/assignmentCompatWithConstructSignatures4.symbols new file mode 100644 index 00000000000..7b46a4ef456 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures4.symbols @@ -0,0 +1,404 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignatures4.ts === +// checking assignment compatibility relations for function types. + +module Errors { +>Errors : Symbol(Errors, Decl(assignmentCompatWithConstructSignatures4.ts, 0, 0)) + + class Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 16)) + + class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithConstructSignatures4.ts, 4, 32)) + + class Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures4.ts, 4, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithConstructSignatures4.ts, 5, 36)) + + class OtherDerived extends Base { bing: string; } +>OtherDerived : Symbol(OtherDerived, Decl(assignmentCompatWithConstructSignatures4.ts, 5, 51)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>bing : Symbol(OtherDerived.bing, Decl(assignmentCompatWithConstructSignatures4.ts, 6, 37)) + + module WithNonGenericSignaturesInBaseType { +>WithNonGenericSignaturesInBaseType : Symbol(WithNonGenericSignaturesInBaseType, Decl(assignmentCompatWithConstructSignatures4.ts, 6, 53)) + + // target type with non-generic call signatures + var a2: new (x: number) => string[]; +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures4.ts, 10, 11)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 10, 21)) + + var a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived2; +>a7 : Symbol(a7, Decl(assignmentCompatWithConstructSignatures4.ts, 11, 11)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 11, 21)) +>arg : Symbol(arg, Decl(assignmentCompatWithConstructSignatures4.ts, 11, 25)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>r : Symbol(r, Decl(assignmentCompatWithConstructSignatures4.ts, 11, 52)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures4.ts, 4, 47)) + + var a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived; +>a8 : Symbol(a8, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 11)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 21)) +>arg : Symbol(arg, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 25)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 47)) +>arg2 : Symbol(arg2, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 52)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>r : Symbol(r, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 80)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) + + var a10: new (...x: Base[]) => Base; +>a10 : Symbol(a10, Decl(assignmentCompatWithConstructSignatures4.ts, 13, 11)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 13, 22)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) + + var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base; +>a11 : Symbol(a11, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 11)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 22)) +>foo : Symbol(foo, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 26)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 41)) +>foo : Symbol(foo, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 46)) +>bar : Symbol(bar, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 59)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) + + var a12: new (x: Array, y: Array) => Array; +>a12 : Symbol(a12, Decl(assignmentCompatWithConstructSignatures4.ts, 15, 11)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 15, 22)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignatures4.ts, 15, 37)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures4.ts, 4, 47)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) + + var a14: { +>a14 : Symbol(a14, Decl(assignmentCompatWithConstructSignatures4.ts, 16, 11)) + + new (x: number): number[]; +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 17, 21)) + + new (x: string): string[]; +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 18, 21)) + + }; + var a15: new (x: { a: string; b: number }) => number; +>a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 11)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 22)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 26)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 37)) + + var a16: { +>a16 : Symbol(a16, Decl(assignmentCompatWithConstructSignatures4.ts, 21, 11)) + + new (x: { +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 22, 21)) + + new (a: number): number; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 23, 25)) + + new (a?: number): number; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 24, 25)) + + }): number[]; + new (x: { +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 26, 21)) + + new (a: boolean): boolean; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 27, 25)) + + new (a?: boolean): boolean; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 28, 25)) + + }): boolean[]; + }; + var a17: { +>a17 : Symbol(a17, Decl(assignmentCompatWithConstructSignatures4.ts, 31, 11)) + + new (x: { +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 32, 21)) + + new (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 33, 25)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 33, 44)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 33, 25)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 33, 25)) + + new (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 34, 25)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 34, 41)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 34, 25)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 34, 25)) + + }): any[]; + new (x: { +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 36, 21)) + + new (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 37, 25)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures4.ts, 4, 47)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 37, 45)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 37, 25)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 37, 25)) + + new (a: T): T; +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 38, 25)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 38, 41)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 38, 25)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 38, 25)) + + }): any[]; + }; + + var b2: new (x: T) => U[]; +>b2 : Symbol(b2, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 21)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 23)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 27)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 21)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 23)) + + a2 = b2; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures4.ts, 10, 11)) +>b2 : Symbol(b2, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 11)) + + b2 = a2; // ok +>b2 : Symbol(b2, Decl(assignmentCompatWithConstructSignatures4.ts, 42, 11)) +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures4.ts, 10, 11)) + + var b7: new (x: (arg: T) => U) => (r: T) => V; +>b7 : Symbol(b7, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 21)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 36)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>V : Symbol(V, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 55)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures4.ts, 4, 47)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 76)) +>arg : Symbol(arg, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 80)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 21)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 36)) +>r : Symbol(r, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 98)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 21)) +>V : Symbol(V, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 55)) + + a7 = b7; // ok +>a7 : Symbol(a7, Decl(assignmentCompatWithConstructSignatures4.ts, 11, 11)) +>b7 : Symbol(b7, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 11)) + + b7 = a7; // ok +>b7 : Symbol(b7, Decl(assignmentCompatWithConstructSignatures4.ts, 46, 11)) +>a7 : Symbol(a7, Decl(assignmentCompatWithConstructSignatures4.ts, 11, 11)) + + var b8: new (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; +>b8 : Symbol(b8, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 21)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 36)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 56)) +>arg : Symbol(arg, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 60)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 21)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 36)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 73)) +>arg2 : Symbol(arg2, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 78)) +>foo : Symbol(foo, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 85)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 36)) +>r : Symbol(r, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 112)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 21)) +>U : Symbol(U, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 36)) + + a8 = b8; // error, type mismatch +>a8 : Symbol(a8, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 11)) +>b8 : Symbol(b8, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 11)) + + b8 = a8; // error +>b8 : Symbol(b8, Decl(assignmentCompatWithConstructSignatures4.ts, 50, 11)) +>a8 : Symbol(a8, Decl(assignmentCompatWithConstructSignatures4.ts, 12, 11)) + + + var b10: new (...x: T[]) => T; +>b10 : Symbol(b10, Decl(assignmentCompatWithConstructSignatures4.ts, 55, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 55, 22)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 55, 41)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 55, 22)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 55, 22)) + + a10 = b10; // ok +>a10 : Symbol(a10, Decl(assignmentCompatWithConstructSignatures4.ts, 13, 11)) +>b10 : Symbol(b10, Decl(assignmentCompatWithConstructSignatures4.ts, 55, 11)) + + b10 = a10; // ok +>b10 : Symbol(b10, Decl(assignmentCompatWithConstructSignatures4.ts, 55, 11)) +>a10 : Symbol(a10, Decl(assignmentCompatWithConstructSignatures4.ts, 13, 11)) + + var b11: new (x: T, y: T) => T; +>b11 : Symbol(b11, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 22)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures4.ts, 3, 31)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 41)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 22)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 46)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 22)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 22)) + + a11 = b11; // ok +>a11 : Symbol(a11, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 11)) +>b11 : Symbol(b11, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 11)) + + b11 = a11; // ok +>b11 : Symbol(b11, Decl(assignmentCompatWithConstructSignatures4.ts, 59, 11)) +>a11 : Symbol(a11, Decl(assignmentCompatWithConstructSignatures4.ts, 14, 11)) + + var b12: new >(x: Array, y: Array) => T; +>b12 : Symbol(b12, Decl(assignmentCompatWithConstructSignatures4.ts, 63, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 63, 22)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures4.ts, 4, 47)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 63, 49)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignatures4.ts, 63, 64)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 63, 22)) + + a12 = b12; // ok +>a12 : Symbol(a12, Decl(assignmentCompatWithConstructSignatures4.ts, 15, 11)) +>b12 : Symbol(b12, Decl(assignmentCompatWithConstructSignatures4.ts, 63, 11)) + + b12 = a12; // ok +>b12 : Symbol(b12, Decl(assignmentCompatWithConstructSignatures4.ts, 63, 11)) +>a12 : Symbol(a12, Decl(assignmentCompatWithConstructSignatures4.ts, 15, 11)) + + var b15: new (x: { a: T; b: T }) => T; +>b15 : Symbol(b15, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 22)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 25)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 29)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 22)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 35)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 22)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 22)) + + a15 = b15; // ok +>a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 11)) +>b15 : Symbol(b15, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 11)) + + b15 = a15; // ok +>b15 : Symbol(b15, Decl(assignmentCompatWithConstructSignatures4.ts, 67, 11)) +>a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 11)) + + var b15a: new (x: { a: T; b: T }) => number; +>b15a : Symbol(b15a, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 23)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures4.ts, 2, 15)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 39)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 43)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 23)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 49)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 23)) + + a15 = b15a; // ok +>a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 11)) +>b15a : Symbol(b15a, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 11)) + + b15a = a15; // ok +>b15a : Symbol(b15a, Decl(assignmentCompatWithConstructSignatures4.ts, 71, 11)) +>a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures4.ts, 20, 11)) + + var b16: new (x: (a: T) => T) => T[]; +>b16 : Symbol(b16, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 22)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 25)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 29)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 22)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 22)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 22)) + + a16 = b16; // error +>a16 : Symbol(a16, Decl(assignmentCompatWithConstructSignatures4.ts, 21, 11)) +>b16 : Symbol(b16, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 11)) + + b16 = a16; // error +>b16 : Symbol(b16, Decl(assignmentCompatWithConstructSignatures4.ts, 75, 11)) +>a16 : Symbol(a16, Decl(assignmentCompatWithConstructSignatures4.ts, 21, 11)) + + var b17: new (x: (a: T) => T) => any[]; +>b17 : Symbol(b17, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 22)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 25)) +>a : Symbol(a, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 29)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 22)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 22)) + + a17 = b17; // error +>a17 : Symbol(a17, Decl(assignmentCompatWithConstructSignatures4.ts, 31, 11)) +>b17 : Symbol(b17, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 11)) + + b17 = a17; // error +>b17 : Symbol(b17, Decl(assignmentCompatWithConstructSignatures4.ts, 79, 11)) +>a17 : Symbol(a17, Decl(assignmentCompatWithConstructSignatures4.ts, 31, 11)) + } + + module WithGenericSignaturesInBaseType { +>WithGenericSignaturesInBaseType : Symbol(WithGenericSignaturesInBaseType, Decl(assignmentCompatWithConstructSignatures4.ts, 82, 5)) + + // target type has generic call signature + var a2: new (x: T) => T[]; +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures4.ts, 86, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 86, 21)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 86, 24)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 86, 21)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 86, 21)) + + var b2: new (x: T) => string[]; +>b2 : Symbol(b2, Decl(assignmentCompatWithConstructSignatures4.ts, 87, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 87, 21)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 87, 24)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 87, 21)) + + a2 = b2; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures4.ts, 86, 11)) +>b2 : Symbol(b2, Decl(assignmentCompatWithConstructSignatures4.ts, 87, 11)) + + b2 = a2; // ok +>b2 : Symbol(b2, Decl(assignmentCompatWithConstructSignatures4.ts, 87, 11)) +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignatures4.ts, 86, 11)) + + // target type has generic call signature + var a3: new (x: T) => string[]; +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures4.ts, 92, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 92, 21)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 92, 24)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 92, 21)) + + var b3: new (x: T) => T[]; +>b3 : Symbol(b3, Decl(assignmentCompatWithConstructSignatures4.ts, 93, 11)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 93, 21)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignatures4.ts, 93, 24)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 93, 21)) +>T : Symbol(T, Decl(assignmentCompatWithConstructSignatures4.ts, 93, 21)) + + a3 = b3; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures4.ts, 92, 11)) +>b3 : Symbol(b3, Decl(assignmentCompatWithConstructSignatures4.ts, 93, 11)) + + b3 = a3; // ok +>b3 : Symbol(b3, Decl(assignmentCompatWithConstructSignatures4.ts, 93, 11)) +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignatures4.ts, 92, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures4.types b/tests/baselines/reference/assignmentCompatWithConstructSignatures4.types new file mode 100644 index 00000000000..1844e5ac657 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures4.types @@ -0,0 +1,428 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignatures4.ts === +// checking assignment compatibility relations for function types. + +module Errors { +>Errors : typeof Errors + + class Base { foo: string; } +>Base : Base +>foo : string + + class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + + class Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + + class OtherDerived extends Base { bing: string; } +>OtherDerived : OtherDerived +>Base : Base +>bing : string + + module WithNonGenericSignaturesInBaseType { +>WithNonGenericSignaturesInBaseType : typeof WithNonGenericSignaturesInBaseType + + // target type with non-generic call signatures + var a2: new (x: number) => string[]; +>a2 : new (x: number) => string[] +>x : number + + var a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived2; +>a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived2 +>x : (arg: Base) => Derived +>arg : Base +>Base : Base +>Derived : Derived +>r : Base +>Base : Base +>Derived2 : Derived2 + + var a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived; +>a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived +>x : (arg: Base) => Derived +>arg : Base +>Base : Base +>Derived : Derived +>y : (arg2: Base) => Derived +>arg2 : Base +>Base : Base +>Derived : Derived +>r : Base +>Base : Base +>Derived : Derived + + var a10: new (...x: Base[]) => Base; +>a10 : new (...x: Base[]) => Base +>x : Base[] +>Base : Base +>Base : Base + + var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base; +>a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base +>x : { foo: string; } +>foo : string +>y : { foo: string; bar: string; } +>foo : string +>bar : string +>Base : Base + + var a12: new (x: Array, y: Array) => Array; +>a12 : new (x: Base[], y: Derived2[]) => Derived[] +>x : Base[] +>Array : T[] +>Base : Base +>y : Derived2[] +>Array : T[] +>Derived2 : Derived2 +>Array : T[] +>Derived : Derived + + var a14: { +>a14 : { new (x: number): number[]; new (x: string): string[]; } + + new (x: number): number[]; +>x : number + + new (x: string): string[]; +>x : string + + }; + var a15: new (x: { a: string; b: number }) => number; +>a15 : new (x: { a: string; b: number; }) => number +>x : { a: string; b: number; } +>a : string +>b : number + + var a16: { +>a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; } + + new (x: { +>x : { new (a: number): number; new (a?: number): number; } + + new (a: number): number; +>a : number + + new (a?: number): number; +>a : number + + }): number[]; + new (x: { +>x : { new (a: boolean): boolean; new (a?: boolean): boolean; } + + new (a: boolean): boolean; +>a : boolean + + new (a?: boolean): boolean; +>a : boolean + + }): boolean[]; + }; + var a17: { +>a17 : { new (x: { new (a: T): T; new (a: T): T; }): any[]; new (x: { new (a: T): T; new (a: T): T; }): any[]; } + + new (x: { +>x : { new (a: T): T; new (a: T): T; } + + new (a: T): T; +>T : T +>Derived : Derived +>a : T +>T : T +>T : T + + new (a: T): T; +>T : T +>Base : Base +>a : T +>T : T +>T : T + + }): any[]; + new (x: { +>x : { new (a: T): T; new (a: T): T; } + + new (a: T): T; +>T : T +>Derived2 : Derived2 +>a : T +>T : T +>T : T + + new (a: T): T; +>T : T +>Base : Base +>a : T +>T : T +>T : T + + }): any[]; + }; + + var b2: new (x: T) => U[]; +>b2 : new (x: T) => U[] +>T : T +>U : U +>x : T +>T : T +>U : U + + a2 = b2; // ok +>a2 = b2 : new (x: T) => U[] +>a2 : new (x: number) => string[] +>b2 : new (x: T) => U[] + + b2 = a2; // ok +>b2 = a2 : new (x: number) => string[] +>b2 : new (x: T) => U[] +>a2 : new (x: number) => string[] + + var b7: new (x: (arg: T) => U) => (r: T) => V; +>b7 : new (x: (arg: T) => U) => (r: T) => V +>T : T +>Base : Base +>U : U +>Derived : Derived +>V : V +>Derived2 : Derived2 +>x : (arg: T) => U +>arg : T +>T : T +>U : U +>r : T +>T : T +>V : V + + a7 = b7; // ok +>a7 = b7 : new (x: (arg: T) => U) => (r: T) => V +>a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived2 +>b7 : new (x: (arg: T) => U) => (r: T) => V + + b7 = a7; // ok +>b7 = a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived2 +>b7 : new (x: (arg: T) => U) => (r: T) => V +>a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived2 + + var b8: new (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; +>b8 : new (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U +>T : T +>Base : Base +>U : U +>Derived : Derived +>x : (arg: T) => U +>arg : T +>T : T +>U : U +>y : (arg2: { foo: number; }) => U +>arg2 : { foo: number; } +>foo : number +>U : U +>r : T +>T : T +>U : U + + a8 = b8; // error, type mismatch +>a8 = b8 : new (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U +>a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived +>b8 : new (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U + + b8 = a8; // error +>b8 = a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived +>b8 : new (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U +>a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived + + + var b10: new (...x: T[]) => T; +>b10 : new (...x: T[]) => T +>T : T +>Derived : Derived +>x : T[] +>T : T +>T : T + + a10 = b10; // ok +>a10 = b10 : new (...x: T[]) => T +>a10 : new (...x: Base[]) => Base +>b10 : new (...x: T[]) => T + + b10 = a10; // ok +>b10 = a10 : new (...x: Base[]) => Base +>b10 : new (...x: T[]) => T +>a10 : new (...x: Base[]) => Base + + var b11: new (x: T, y: T) => T; +>b11 : new (x: T, y: T) => T +>T : T +>Derived : Derived +>x : T +>T : T +>y : T +>T : T +>T : T + + a11 = b11; // ok +>a11 = b11 : new (x: T, y: T) => T +>a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base +>b11 : new (x: T, y: T) => T + + b11 = a11; // ok +>b11 = a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base +>b11 : new (x: T, y: T) => T +>a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base + + var b12: new >(x: Array, y: Array) => T; +>b12 : new (x: Base[], y: Base[]) => T +>T : T +>Array : T[] +>Derived2 : Derived2 +>x : Base[] +>Array : T[] +>Base : Base +>y : Base[] +>Array : T[] +>Base : Base +>T : T + + a12 = b12; // ok +>a12 = b12 : new (x: Base[], y: Base[]) => T +>a12 : new (x: Base[], y: Derived2[]) => Derived[] +>b12 : new (x: Base[], y: Base[]) => T + + b12 = a12; // ok +>b12 = a12 : new (x: Base[], y: Derived2[]) => Derived[] +>b12 : new (x: Base[], y: Base[]) => T +>a12 : new (x: Base[], y: Derived2[]) => Derived[] + + var b15: new (x: { a: T; b: T }) => T; +>b15 : new (x: { a: T; b: T; }) => T +>T : T +>x : { a: T; b: T; } +>a : T +>T : T +>b : T +>T : T +>T : T + + a15 = b15; // ok +>a15 = b15 : new (x: { a: T; b: T; }) => T +>a15 : new (x: { a: string; b: number; }) => number +>b15 : new (x: { a: T; b: T; }) => T + + b15 = a15; // ok +>b15 = a15 : new (x: { a: string; b: number; }) => number +>b15 : new (x: { a: T; b: T; }) => T +>a15 : new (x: { a: string; b: number; }) => number + + var b15a: new (x: { a: T; b: T }) => number; +>b15a : new (x: { a: T; b: T; }) => number +>T : T +>Base : Base +>x : { a: T; b: T; } +>a : T +>T : T +>b : T +>T : T + + a15 = b15a; // ok +>a15 = b15a : new (x: { a: T; b: T; }) => number +>a15 : new (x: { a: string; b: number; }) => number +>b15a : new (x: { a: T; b: T; }) => number + + b15a = a15; // ok +>b15a = a15 : new (x: { a: string; b: number; }) => number +>b15a : new (x: { a: T; b: T; }) => number +>a15 : new (x: { a: string; b: number; }) => number + + var b16: new (x: (a: T) => T) => T[]; +>b16 : new (x: (a: T) => T) => T[] +>T : T +>x : (a: T) => T +>a : T +>T : T +>T : T +>T : T + + a16 = b16; // error +>a16 = b16 : new (x: (a: T) => T) => T[] +>a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; } +>b16 : new (x: (a: T) => T) => T[] + + b16 = a16; // error +>b16 = a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; } +>b16 : new (x: (a: T) => T) => T[] +>a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; } + + var b17: new (x: (a: T) => T) => any[]; +>b17 : new (x: (a: T) => T) => any[] +>T : T +>x : (a: T) => T +>a : T +>T : T +>T : T + + a17 = b17; // error +>a17 = b17 : new (x: (a: T) => T) => any[] +>a17 : { new (x: { new (a: T): T; new (a: T): T; }): any[]; new (x: { new (a: T): T; new (a: T): T; }): any[]; } +>b17 : new (x: (a: T) => T) => any[] + + b17 = a17; // error +>b17 = a17 : { new (x: { new (a: T): T; new (a: T): T; }): any[]; new (x: { new (a: T): T; new (a: T): T; }): any[]; } +>b17 : new (x: (a: T) => T) => any[] +>a17 : { new (x: { new (a: T): T; new (a: T): T; }): any[]; new (x: { new (a: T): T; new (a: T): T; }): any[]; } + } + + module WithGenericSignaturesInBaseType { +>WithGenericSignaturesInBaseType : typeof WithGenericSignaturesInBaseType + + // target type has generic call signature + var a2: new (x: T) => T[]; +>a2 : new (x: T) => T[] +>T : T +>x : T +>T : T +>T : T + + var b2: new (x: T) => string[]; +>b2 : new (x: T) => string[] +>T : T +>x : T +>T : T + + a2 = b2; // ok +>a2 = b2 : new (x: T) => string[] +>a2 : new (x: T) => T[] +>b2 : new (x: T) => string[] + + b2 = a2; // ok +>b2 = a2 : new (x: T) => T[] +>b2 : new (x: T) => string[] +>a2 : new (x: T) => T[] + + // target type has generic call signature + var a3: new (x: T) => string[]; +>a3 : new (x: T) => string[] +>T : T +>x : T +>T : T + + var b3: new (x: T) => T[]; +>b3 : new (x: T) => T[] +>T : T +>x : T +>T : T +>T : T + + a3 = b3; // ok +>a3 = b3 : new (x: T) => T[] +>a3 : new (x: T) => string[] +>b3 : new (x: T) => T[] + + b3 = a3; // ok +>b3 = a3 : new (x: T) => string[] +>b3 : new (x: T) => T[] +>a3 : new (x: T) => string[] + } +} diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.symbols b/tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.symbols new file mode 100644 index 00000000000..5cd4f91642d --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.symbols @@ -0,0 +1,237 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignaturesWithOptionalParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the base type + +interface Base { +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 0, 0)) + + a: new () => number; +>a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) + + a2: new (x?: number) => number; +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 13)) + + a3: new (x: number) => number; +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 13)) + + a4: new (x: number, y?: number) => number; +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 13)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 23)) + + a5: new (x?: number, y?: number) => number; +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 13)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 24)) + + a6: new (x: number, y: number) => number; +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 8, 13)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 8, 23)) +} +var b: Base; +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>Base : Symbol(Base, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 0, 0)) + +var a: new () => number; +>a : Symbol(a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 12, 3)) + + a = b.a; // ok +>a : Symbol(a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) + + a = b.a2; // ok +>a : Symbol(a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) + + a = b.a3; // error +>a : Symbol(a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) + + a = b.a4; // error +>a : Symbol(a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) + + a = b.a5; // ok +>a : Symbol(a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) + + a = b.a6; // error +>a : Symbol(a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 12, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) + +var a2: new (x?: number) => number; +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 13)) + + a2 = b.a; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) + + a2 = b.a2; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) + + a2 = b.a3; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) + + a2 = b.a4; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) + + a2 = b.a5; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) + + a2 = b.a6; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 20, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) + +var a3: new (x: number) => number; +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 13)) + + a3 = b.a; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) + + a3 = b.a2; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) + + a3 = b.a3; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) + + a3 = b.a4; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) + + a3 = b.a5; // ok +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) + + a3 = b.a6; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 28, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) + +var a4: new (x: number, y?: number) => number; +>a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 13)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 23)) + + a4 = b.a; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) + + a4 = b.a2; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) + + a4 = b.a3; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) + + a4 = b.a4; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) + + a4 = b.a5; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) + + a4 = b.a6; // ok +>a4 : Symbol(a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 36, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) + +var a5: new (x?: number, y?: number) => number; +>a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 3)) +>x : Symbol(x, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 13)) +>y : Symbol(y, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 24)) + + a5 = b.a; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 3)) +>b.a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a : Symbol(Base.a, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 2, 16)) + + a5 = b.a2; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 3)) +>b.a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 3, 24)) + + a5 = b.a3; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 3)) +>b.a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 4, 35)) + + a5 = b.a4; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 3)) +>b.a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 5, 34)) + + a5 = b.a5; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 3)) +>b.a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 6, 46)) + + a5 = b.a6; // ok +>a5 : Symbol(a5, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 44, 3)) +>b.a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) +>b : Symbol(b, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 10, 3)) +>a6 : Symbol(Base.a6, Decl(assignmentCompatWithConstructSignaturesWithOptionalParameters.ts, 7, 47)) + diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.types b/tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.types new file mode 100644 index 00000000000..c2f13da17bf --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithConstructSignaturesWithOptionalParameters.types @@ -0,0 +1,267 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithConstructSignaturesWithOptionalParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the base type + +interface Base { +>Base : Base + + a: new () => number; +>a : new () => number + + a2: new (x?: number) => number; +>a2 : new (x?: number) => number +>x : number + + a3: new (x: number) => number; +>a3 : new (x: number) => number +>x : number + + a4: new (x: number, y?: number) => number; +>a4 : new (x: number, y?: number) => number +>x : number +>y : number + + a5: new (x?: number, y?: number) => number; +>a5 : new (x?: number, y?: number) => number +>x : number +>y : number + + a6: new (x: number, y: number) => number; +>a6 : new (x: number, y: number) => number +>x : number +>y : number +} +var b: Base; +>b : Base +>Base : Base + +var a: new () => number; +>a : new () => number + + a = b.a; // ok +>a = b.a : new () => number +>a : new () => number +>b.a : new () => number +>b : Base +>a : new () => number + + a = b.a2; // ok +>a = b.a2 : new (x?: number) => number +>a : new () => number +>b.a2 : new (x?: number) => number +>b : Base +>a2 : new (x?: number) => number + + a = b.a3; // error +>a = b.a3 : new (x: number) => number +>a : new () => number +>b.a3 : new (x: number) => number +>b : Base +>a3 : new (x: number) => number + + a = b.a4; // error +>a = b.a4 : new (x: number, y?: number) => number +>a : new () => number +>b.a4 : new (x: number, y?: number) => number +>b : Base +>a4 : new (x: number, y?: number) => number + + a = b.a5; // ok +>a = b.a5 : new (x?: number, y?: number) => number +>a : new () => number +>b.a5 : new (x?: number, y?: number) => number +>b : Base +>a5 : new (x?: number, y?: number) => number + + a = b.a6; // error +>a = b.a6 : new (x: number, y: number) => number +>a : new () => number +>b.a6 : new (x: number, y: number) => number +>b : Base +>a6 : new (x: number, y: number) => number + +var a2: new (x?: number) => number; +>a2 : new (x?: number) => number +>x : number + + a2 = b.a; // ok +>a2 = b.a : new () => number +>a2 : new (x?: number) => number +>b.a : new () => number +>b : Base +>a : new () => number + + a2 = b.a2; // ok +>a2 = b.a2 : new (x?: number) => number +>a2 : new (x?: number) => number +>b.a2 : new (x?: number) => number +>b : Base +>a2 : new (x?: number) => number + + a2 = b.a3; // ok +>a2 = b.a3 : new (x: number) => number +>a2 : new (x?: number) => number +>b.a3 : new (x: number) => number +>b : Base +>a3 : new (x: number) => number + + a2 = b.a4; // ok +>a2 = b.a4 : new (x: number, y?: number) => number +>a2 : new (x?: number) => number +>b.a4 : new (x: number, y?: number) => number +>b : Base +>a4 : new (x: number, y?: number) => number + + a2 = b.a5; // ok +>a2 = b.a5 : new (x?: number, y?: number) => number +>a2 : new (x?: number) => number +>b.a5 : new (x?: number, y?: number) => number +>b : Base +>a5 : new (x?: number, y?: number) => number + + a2 = b.a6; // error +>a2 = b.a6 : new (x: number, y: number) => number +>a2 : new (x?: number) => number +>b.a6 : new (x: number, y: number) => number +>b : Base +>a6 : new (x: number, y: number) => number + +var a3: new (x: number) => number; +>a3 : new (x: number) => number +>x : number + + a3 = b.a; // ok +>a3 = b.a : new () => number +>a3 : new (x: number) => number +>b.a : new () => number +>b : Base +>a : new () => number + + a3 = b.a2; // ok +>a3 = b.a2 : new (x?: number) => number +>a3 : new (x: number) => number +>b.a2 : new (x?: number) => number +>b : Base +>a2 : new (x?: number) => number + + a3 = b.a3; // ok +>a3 = b.a3 : new (x: number) => number +>a3 : new (x: number) => number +>b.a3 : new (x: number) => number +>b : Base +>a3 : new (x: number) => number + + a3 = b.a4; // ok +>a3 = b.a4 : new (x: number, y?: number) => number +>a3 : new (x: number) => number +>b.a4 : new (x: number, y?: number) => number +>b : Base +>a4 : new (x: number, y?: number) => number + + a3 = b.a5; // ok +>a3 = b.a5 : new (x?: number, y?: number) => number +>a3 : new (x: number) => number +>b.a5 : new (x?: number, y?: number) => number +>b : Base +>a5 : new (x?: number, y?: number) => number + + a3 = b.a6; // error +>a3 = b.a6 : new (x: number, y: number) => number +>a3 : new (x: number) => number +>b.a6 : new (x: number, y: number) => number +>b : Base +>a6 : new (x: number, y: number) => number + +var a4: new (x: number, y?: number) => number; +>a4 : new (x: number, y?: number) => number +>x : number +>y : number + + a4 = b.a; // ok +>a4 = b.a : new () => number +>a4 : new (x: number, y?: number) => number +>b.a : new () => number +>b : Base +>a : new () => number + + a4 = b.a2; // ok +>a4 = b.a2 : new (x?: number) => number +>a4 : new (x: number, y?: number) => number +>b.a2 : new (x?: number) => number +>b : Base +>a2 : new (x?: number) => number + + a4 = b.a3; // ok +>a4 = b.a3 : new (x: number) => number +>a4 : new (x: number, y?: number) => number +>b.a3 : new (x: number) => number +>b : Base +>a3 : new (x: number) => number + + a4 = b.a4; // ok +>a4 = b.a4 : new (x: number, y?: number) => number +>a4 : new (x: number, y?: number) => number +>b.a4 : new (x: number, y?: number) => number +>b : Base +>a4 : new (x: number, y?: number) => number + + a4 = b.a5; // ok +>a4 = b.a5 : new (x?: number, y?: number) => number +>a4 : new (x: number, y?: number) => number +>b.a5 : new (x?: number, y?: number) => number +>b : Base +>a5 : new (x?: number, y?: number) => number + + a4 = b.a6; // ok +>a4 = b.a6 : new (x: number, y: number) => number +>a4 : new (x: number, y?: number) => number +>b.a6 : new (x: number, y: number) => number +>b : Base +>a6 : new (x: number, y: number) => number + +var a5: new (x?: number, y?: number) => number; +>a5 : new (x?: number, y?: number) => number +>x : number +>y : number + + a5 = b.a; // ok +>a5 = b.a : new () => number +>a5 : new (x?: number, y?: number) => number +>b.a : new () => number +>b : Base +>a : new () => number + + a5 = b.a2; // ok +>a5 = b.a2 : new (x?: number) => number +>a5 : new (x?: number, y?: number) => number +>b.a2 : new (x?: number) => number +>b : Base +>a2 : new (x?: number) => number + + a5 = b.a3; // ok +>a5 = b.a3 : new (x: number) => number +>a5 : new (x?: number, y?: number) => number +>b.a3 : new (x: number) => number +>b : Base +>a3 : new (x: number) => number + + a5 = b.a4; // ok +>a5 = b.a4 : new (x: number, y?: number) => number +>a5 : new (x?: number, y?: number) => number +>b.a4 : new (x: number, y?: number) => number +>b : Base +>a4 : new (x: number, y?: number) => number + + a5 = b.a5; // ok +>a5 = b.a5 : new (x?: number, y?: number) => number +>a5 : new (x?: number, y?: number) => number +>b.a5 : new (x?: number, y?: number) => number +>b : Base +>a5 : new (x?: number, y?: number) => number + + a5 = b.a6; // ok +>a5 = b.a6 : new (x: number, y: number) => number +>a5 : new (x?: number, y?: number) => number +>b.a6 : new (x: number, y: number) => number +>b : Base +>a6 : new (x: number, y: number) => number + diff --git a/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.symbols b/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.symbols new file mode 100644 index 00000000000..e3f1d226283 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.symbols @@ -0,0 +1,666 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the target for assignment + +module ClassTypeParam { +>ClassTypeParam : Symbol(ClassTypeParam, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 0, 0)) + + class Base { +>Base : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + a: () => T; +>a : Symbol(Base.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 19)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + a2: (x?: T) => T; +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 4, 19)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + a3: (x: T) => T; +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + a4: (x: T, y?: T) => T; +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 18)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + a5: (x?: T, y?: T) => T; +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 8, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 8, 19)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + init = () => { +>init : Symbol(Base.init, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 8, 32)) + + this.a = () => null; // ok, same T of required params +>this.a : Symbol(Base.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 19)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a : Symbol(Base.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 19)) + + this.a = (x?: T) => null; // ok, same T of required params +>this.a : Symbol(Base.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 19)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a : Symbol(Base.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 19)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 12, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a = (x: T) => null; // error, too many required params +>this.a : Symbol(Base.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 19)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a : Symbol(Base.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 19)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 13, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a2 = () => null; // ok, same T of required params +>this.a2 : Symbol(Base.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 4, 19)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 4, 19)) + + this.a2 = (x?: T) => null; // ok, same T of required params +>this.a2 : Symbol(Base.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 4, 19)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 4, 19)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 16, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a2 = (x: T) => null; // ok, same number of params +>this.a2 : Symbol(Base.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 4, 19)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a2 : Symbol(Base.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 4, 19)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 17, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a3 = () => null; // ok, fewer required params +>this.a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) + + this.a3 = (x?: T) => null; // ok, fewer required params +>this.a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 20, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a3 = (x: T) => null; // ok, same T of required params +>this.a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 21, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a3 = (x: T, y: T) => null; // error, too many required params +>this.a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a3 : Symbol(Base.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 5, 25)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 22, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 22, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a4 = () => null; // ok, fewer required params +>this.a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) + + this.a4 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 25, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 25, 29)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a4 = (x: T) => null; // ok, same T of required params +>this.a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 26, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a4 = (x: T, y: T) => null; // ok, same number of params +>this.a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a4 : Symbol(Base.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 6, 24)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 27, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 27, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + + this.a5 = () => null; // ok, fewer required params +>this.a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) + + this.a5 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 31, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 31, 29)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a5 = (x: T) => null; // ok, all present params match +>this.a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 32, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + + this.a5 = (x: T, y: T) => null; // ok, same number of params +>this.a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>this : Symbol(Base, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 2, 23)) +>a5 : Symbol(Base.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 7, 31)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 33, 23)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 33, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 3, 15)) + } + } +} + +module GenericSignaturesInvalid { +>GenericSignaturesInvalid : Symbol(GenericSignaturesInvalid, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 36, 1)) + + class Base2 { +>Base2 : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 38, 33)) + + a: () => T; +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 12)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 12)) + + a2: (x?: T) => T; +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 13)) + + a3: (x: T) => T; +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 13)) + + a4: (x: T, y?: T) => T; +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 13)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 21)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 13)) + + a5: (x?: T, y?: T) => T; +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 45, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 45, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 45, 13)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 45, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 45, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 45, 13)) + } + + class Target { +>Target : Symbol(Target, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 46, 5)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) + + a: () => T; +>a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) + + a2: (x?: T) => T; +>a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) + + a3: (x: T) => T; +>a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) + + a4: (x: T, y?: T) => T; +>a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 18)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) + + a5: (x?: T, y?: T) => T; +>a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 53, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 53, 19)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 17)) + } + + + function foo() { +>foo : Symbol(foo, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 54, 5)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 57, 17)) + + var b: Base2; +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>Base2 : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 38, 33)) + + var t: Target; +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>Target : Symbol(Target, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 46, 5)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 57, 17)) + + // all errors + b.a = t.a; +>b.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>t.a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) + + b.a = t.a2; +>b.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>t.a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) + + b.a = t.a3; +>b.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>t.a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) + + b.a = t.a4; +>b.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>t.a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) + + b.a = t.a5; +>b.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 40, 17)) +>t.a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) + + b.a2 = t.a; +>b.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>t.a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) + + b.a2 = t.a2; +>b.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>t.a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) + + b.a2 = t.a3; +>b.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>t.a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) + + b.a2 = t.a4; +>b.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>t.a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) + + b.a2 = t.a5; +>b.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 41, 22)) +>t.a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) + + b.a3 = t.a; +>b.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>t.a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) + + b.a3 = t.a2; +>b.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>t.a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) + + b.a3 = t.a3; +>b.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>t.a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) + + b.a3 = t.a4; +>b.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>t.a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) + + b.a3 = t.a5; +>b.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 42, 28)) +>t.a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) + + b.a4 = t.a; +>b.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>t.a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) + + b.a4 = t.a2; +>b.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>t.a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) + + b.a4 = t.a3; +>b.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>t.a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) + + b.a4 = t.a4; +>b.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>t.a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) + + b.a4 = t.a5; +>b.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 43, 27)) +>t.a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) + + b.a5 = t.a; +>b.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>t.a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a : Symbol(Target.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 48, 21)) + + b.a5 = t.a2; +>b.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>t.a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a2 : Symbol(Target.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 49, 19)) + + b.a5 = t.a3; +>b.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>t.a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a3 : Symbol(Target.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 50, 25)) + + b.a5 = t.a4; +>b.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>t.a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a4 : Symbol(Target.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 51, 24)) + + b.a5 = t.a5; +>b.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>b : Symbol(b, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 58, 11)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 44, 34)) +>t.a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) +>t : Symbol(t, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 59, 11)) +>a5 : Symbol(Target.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 52, 31)) + } +} + +module GenericSignaturesValid { +>GenericSignaturesValid : Symbol(GenericSignaturesValid, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 92, 1)) + + class Base2 { +>Base2 : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) + + a: () => T; +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 96, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 12)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 12)) + + a2: (x?: T) => T; +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 13)) + + a3: (x: T) => T; +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 13)) + + a4: (x: T, y?: T) => T; +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 13)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 21)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 13)) + + a5: (x?: T, y?: T) => T; +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 101, 13)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 101, 16)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 101, 13)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 101, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 101, 13)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 101, 13)) + + init = () => { +>init : Symbol(Base2.init, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 101, 35)) + + this.a = () => null; // ok, same T of required params +>this.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 96, 17)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 96, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 104, 22)) + + this.a = (x?: T) => null; // ok, same T of required params +>this.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 96, 17)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 96, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 105, 22)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 105, 25)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 105, 22)) + + this.a = (x: T) => null; // error, too many required params +>this.a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 96, 17)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a : Symbol(Base2.a, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 96, 17)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 106, 22)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 106, 25)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 106, 22)) + + this.a2 = () => null; // ok, same T of required params +>this.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 22)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 108, 23)) + + this.a2 = (x?: T) => null; // ok, same T of required params +>this.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 22)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 109, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 109, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 109, 23)) + + this.a2 = (x: T) => null; // ok, same number of params +>this.a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 22)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a2 : Symbol(Base2.a2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 97, 22)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 110, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 110, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 110, 23)) + + this.a3 = () => null; // ok, fewer required params +>this.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 112, 23)) + + this.a3 = (x?: T) => null; // ok, fewer required params +>this.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 113, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 113, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 113, 23)) + + this.a3 = (x: T) => null; // ok, same T of required params +>this.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 114, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 114, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 114, 23)) + + this.a3 = (x: T, y: T) => null; // error, too many required params +>this.a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a3 : Symbol(Base2.a3, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 98, 28)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 115, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 115, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 115, 23)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 115, 31)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 115, 23)) + + this.a4 = () => null; // ok, fewer required params +>this.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 117, 23)) + + this.a4 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 118, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 118, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 118, 23)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 118, 32)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 118, 23)) + + this.a4 = (x: T) => null; // ok, same T of required params +>this.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 119, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 119, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 119, 23)) + + this.a4 = (x: T, y: T) => null; // ok, same number of params +>this.a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a4 : Symbol(Base2.a4, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 99, 27)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 120, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 120, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 120, 23)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 120, 31)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 120, 23)) + + + this.a5 = () => null; // ok, fewer required params +>this.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 123, 23)) + + this.a5 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 124, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 124, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 124, 23)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 124, 32)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 124, 23)) + + this.a5 = (x: T) => null; // ok, all present params match +>this.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 125, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 125, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 125, 23)) + + this.a5 = (x: T, y: T) => null; // ok, same number of params +>this.a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>this : Symbol(Base2, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 94, 31)) +>a5 : Symbol(Base2.a5, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 100, 34)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 126, 23)) +>x : Symbol(x, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 126, 26)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 126, 23)) +>y : Symbol(y, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 126, 31)) +>T : Symbol(T, Decl(assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts, 126, 23)) + } + } +} diff --git a/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types b/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types new file mode 100644 index 00000000000..28bcc4e190a --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.types @@ -0,0 +1,801 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithGenericCallSignaturesWithOptionalParameters.ts === +// call signatures in derived types must have the same or fewer optional parameters as the target for assignment + +module ClassTypeParam { +>ClassTypeParam : typeof ClassTypeParam + + class Base { +>Base : Base +>T : T + + a: () => T; +>a : () => T +>T : T + + a2: (x?: T) => T; +>a2 : (x?: T) => T +>x : T +>T : T +>T : T + + a3: (x: T) => T; +>a3 : (x: T) => T +>x : T +>T : T +>T : T + + a4: (x: T, y?: T) => T; +>a4 : (x: T, y?: T) => T +>x : T +>T : T +>y : T +>T : T +>T : T + + a5: (x?: T, y?: T) => T; +>a5 : (x?: T, y?: T) => T +>x : T +>T : T +>y : T +>T : T +>T : T + + init = () => { +>init : () => void +>() => { 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 } : () => void + + this.a = () => null; // ok, same T of required params +>this.a = () => null : () => any +>this.a : () => T +>this : this +>a : () => T +>() => null : () => any +>null : null + + this.a = (x?: T) => null; // ok, same T of required params +>this.a = (x?: T) => null : (x?: T) => any +>this.a : () => T +>this : this +>a : () => T +>(x?: T) => null : (x?: T) => any +>x : T +>T : T +>null : null + + this.a = (x: T) => null; // error, too many required params +>this.a = (x: T) => null : (x: T) => any +>this.a : () => T +>this : this +>a : () => T +>(x: T) => null : (x: T) => any +>x : T +>T : T +>null : null + + this.a2 = () => null; // ok, same T of required params +>this.a2 = () => null : () => any +>this.a2 : (x?: T) => T +>this : this +>a2 : (x?: T) => T +>() => null : () => any +>null : null + + this.a2 = (x?: T) => null; // ok, same T of required params +>this.a2 = (x?: T) => null : (x?: T) => any +>this.a2 : (x?: T) => T +>this : this +>a2 : (x?: T) => T +>(x?: T) => null : (x?: T) => any +>x : T +>T : T +>null : null + + this.a2 = (x: T) => null; // ok, same number of params +>this.a2 = (x: T) => null : (x: T) => any +>this.a2 : (x?: T) => T +>this : this +>a2 : (x?: T) => T +>(x: T) => null : (x: T) => any +>x : T +>T : T +>null : null + + this.a3 = () => null; // ok, fewer required params +>this.a3 = () => null : () => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>() => null : () => any +>null : null + + this.a3 = (x?: T) => null; // ok, fewer required params +>this.a3 = (x?: T) => null : (x?: T) => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>(x?: T) => null : (x?: T) => any +>x : T +>T : T +>null : null + + this.a3 = (x: T) => null; // ok, same T of required params +>this.a3 = (x: T) => null : (x: T) => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>(x: T) => null : (x: T) => any +>x : T +>T : T +>null : null + + this.a3 = (x: T, y: T) => null; // error, too many required params +>this.a3 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>(x: T, y: T) => null : (x: T, y: T) => any +>x : T +>T : T +>y : T +>T : T +>null : null + + this.a4 = () => null; // ok, fewer required params +>this.a4 = () => null : () => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>() => null : () => any +>null : null + + this.a4 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a4 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>(x?: T, y?: T) => null : (x?: T, y?: T) => any +>x : T +>T : T +>y : T +>T : T +>null : null + + this.a4 = (x: T) => null; // ok, same T of required params +>this.a4 = (x: T) => null : (x: T) => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>(x: T) => null : (x: T) => any +>x : T +>T : T +>null : null + + this.a4 = (x: T, y: T) => null; // ok, same number of params +>this.a4 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>(x: T, y: T) => null : (x: T, y: T) => any +>x : T +>T : T +>y : T +>T : T +>null : null + + + this.a5 = () => null; // ok, fewer required params +>this.a5 = () => null : () => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>() => null : () => any +>null : null + + this.a5 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a5 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>(x?: T, y?: T) => null : (x?: T, y?: T) => any +>x : T +>T : T +>y : T +>T : T +>null : null + + this.a5 = (x: T) => null; // ok, all present params match +>this.a5 = (x: T) => null : (x: T) => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>(x: T) => null : (x: T) => any +>x : T +>T : T +>null : null + + this.a5 = (x: T, y: T) => null; // ok, same number of params +>this.a5 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>(x: T, y: T) => null : (x: T, y: T) => any +>x : T +>T : T +>y : T +>T : T +>null : null + } + } +} + +module GenericSignaturesInvalid { +>GenericSignaturesInvalid : typeof GenericSignaturesInvalid + + class Base2 { +>Base2 : Base2 + + a: () => T; +>a : () => T +>T : T +>T : T + + a2: (x?: T) => T; +>a2 : (x?: T) => T +>T : T +>x : T +>T : T +>T : T + + a3: (x: T) => T; +>a3 : (x: T) => T +>T : T +>x : T +>T : T +>T : T + + a4: (x: T, y?: T) => T; +>a4 : (x: T, y?: T) => T +>T : T +>x : T +>T : T +>y : T +>T : T +>T : T + + a5: (x?: T, y?: T) => T; +>a5 : (x?: T, y?: T) => T +>T : T +>x : T +>T : T +>y : T +>T : T +>T : T + } + + class Target { +>Target : Target +>T : T + + a: () => T; +>a : () => T +>T : T + + a2: (x?: T) => T; +>a2 : (x?: T) => T +>x : T +>T : T +>T : T + + a3: (x: T) => T; +>a3 : (x: T) => T +>x : T +>T : T +>T : T + + a4: (x: T, y?: T) => T; +>a4 : (x: T, y?: T) => T +>x : T +>T : T +>y : T +>T : T +>T : T + + a5: (x?: T, y?: T) => T; +>a5 : (x?: T, y?: T) => T +>x : T +>T : T +>y : T +>T : T +>T : T + } + + + function foo() { +>foo : () => void +>T : T + + var b: Base2; +>b : Base2 +>Base2 : Base2 + + var t: Target; +>t : Target +>Target : Target +>T : T + + // all errors + b.a = t.a; +>b.a = t.a : () => T +>b.a : () => T +>b : Base2 +>a : () => T +>t.a : () => T +>t : Target +>a : () => T + + b.a = t.a2; +>b.a = t.a2 : (x?: T) => T +>b.a : () => T +>b : Base2 +>a : () => T +>t.a2 : (x?: T) => T +>t : Target +>a2 : (x?: T) => T + + b.a = t.a3; +>b.a = t.a3 : (x: T) => T +>b.a : () => T +>b : Base2 +>a : () => T +>t.a3 : (x: T) => T +>t : Target +>a3 : (x: T) => T + + b.a = t.a4; +>b.a = t.a4 : (x: T, y?: T) => T +>b.a : () => T +>b : Base2 +>a : () => T +>t.a4 : (x: T, y?: T) => T +>t : Target +>a4 : (x: T, y?: T) => T + + b.a = t.a5; +>b.a = t.a5 : (x?: T, y?: T) => T +>b.a : () => T +>b : Base2 +>a : () => T +>t.a5 : (x?: T, y?: T) => T +>t : Target +>a5 : (x?: T, y?: T) => T + + b.a2 = t.a; +>b.a2 = t.a : () => T +>b.a2 : (x?: T) => T +>b : Base2 +>a2 : (x?: T) => T +>t.a : () => T +>t : Target +>a : () => T + + b.a2 = t.a2; +>b.a2 = t.a2 : (x?: T) => T +>b.a2 : (x?: T) => T +>b : Base2 +>a2 : (x?: T) => T +>t.a2 : (x?: T) => T +>t : Target +>a2 : (x?: T) => T + + b.a2 = t.a3; +>b.a2 = t.a3 : (x: T) => T +>b.a2 : (x?: T) => T +>b : Base2 +>a2 : (x?: T) => T +>t.a3 : (x: T) => T +>t : Target +>a3 : (x: T) => T + + b.a2 = t.a4; +>b.a2 = t.a4 : (x: T, y?: T) => T +>b.a2 : (x?: T) => T +>b : Base2 +>a2 : (x?: T) => T +>t.a4 : (x: T, y?: T) => T +>t : Target +>a4 : (x: T, y?: T) => T + + b.a2 = t.a5; +>b.a2 = t.a5 : (x?: T, y?: T) => T +>b.a2 : (x?: T) => T +>b : Base2 +>a2 : (x?: T) => T +>t.a5 : (x?: T, y?: T) => T +>t : Target +>a5 : (x?: T, y?: T) => T + + b.a3 = t.a; +>b.a3 = t.a : () => T +>b.a3 : (x: T) => T +>b : Base2 +>a3 : (x: T) => T +>t.a : () => T +>t : Target +>a : () => T + + b.a3 = t.a2; +>b.a3 = t.a2 : (x?: T) => T +>b.a3 : (x: T) => T +>b : Base2 +>a3 : (x: T) => T +>t.a2 : (x?: T) => T +>t : Target +>a2 : (x?: T) => T + + b.a3 = t.a3; +>b.a3 = t.a3 : (x: T) => T +>b.a3 : (x: T) => T +>b : Base2 +>a3 : (x: T) => T +>t.a3 : (x: T) => T +>t : Target +>a3 : (x: T) => T + + b.a3 = t.a4; +>b.a3 = t.a4 : (x: T, y?: T) => T +>b.a3 : (x: T) => T +>b : Base2 +>a3 : (x: T) => T +>t.a4 : (x: T, y?: T) => T +>t : Target +>a4 : (x: T, y?: T) => T + + b.a3 = t.a5; +>b.a3 = t.a5 : (x?: T, y?: T) => T +>b.a3 : (x: T) => T +>b : Base2 +>a3 : (x: T) => T +>t.a5 : (x?: T, y?: T) => T +>t : Target +>a5 : (x?: T, y?: T) => T + + b.a4 = t.a; +>b.a4 = t.a : () => T +>b.a4 : (x: T, y?: T) => T +>b : Base2 +>a4 : (x: T, y?: T) => T +>t.a : () => T +>t : Target +>a : () => T + + b.a4 = t.a2; +>b.a4 = t.a2 : (x?: T) => T +>b.a4 : (x: T, y?: T) => T +>b : Base2 +>a4 : (x: T, y?: T) => T +>t.a2 : (x?: T) => T +>t : Target +>a2 : (x?: T) => T + + b.a4 = t.a3; +>b.a4 = t.a3 : (x: T) => T +>b.a4 : (x: T, y?: T) => T +>b : Base2 +>a4 : (x: T, y?: T) => T +>t.a3 : (x: T) => T +>t : Target +>a3 : (x: T) => T + + b.a4 = t.a4; +>b.a4 = t.a4 : (x: T, y?: T) => T +>b.a4 : (x: T, y?: T) => T +>b : Base2 +>a4 : (x: T, y?: T) => T +>t.a4 : (x: T, y?: T) => T +>t : Target +>a4 : (x: T, y?: T) => T + + b.a4 = t.a5; +>b.a4 = t.a5 : (x?: T, y?: T) => T +>b.a4 : (x: T, y?: T) => T +>b : Base2 +>a4 : (x: T, y?: T) => T +>t.a5 : (x?: T, y?: T) => T +>t : Target +>a5 : (x?: T, y?: T) => T + + b.a5 = t.a; +>b.a5 = t.a : () => T +>b.a5 : (x?: T, y?: T) => T +>b : Base2 +>a5 : (x?: T, y?: T) => T +>t.a : () => T +>t : Target +>a : () => T + + b.a5 = t.a2; +>b.a5 = t.a2 : (x?: T) => T +>b.a5 : (x?: T, y?: T) => T +>b : Base2 +>a5 : (x?: T, y?: T) => T +>t.a2 : (x?: T) => T +>t : Target +>a2 : (x?: T) => T + + b.a5 = t.a3; +>b.a5 = t.a3 : (x: T) => T +>b.a5 : (x?: T, y?: T) => T +>b : Base2 +>a5 : (x?: T, y?: T) => T +>t.a3 : (x: T) => T +>t : Target +>a3 : (x: T) => T + + b.a5 = t.a4; +>b.a5 = t.a4 : (x: T, y?: T) => T +>b.a5 : (x?: T, y?: T) => T +>b : Base2 +>a5 : (x?: T, y?: T) => T +>t.a4 : (x: T, y?: T) => T +>t : Target +>a4 : (x: T, y?: T) => T + + b.a5 = t.a5; +>b.a5 = t.a5 : (x?: T, y?: T) => T +>b.a5 : (x?: T, y?: T) => T +>b : Base2 +>a5 : (x?: T, y?: T) => T +>t.a5 : (x?: T, y?: T) => T +>t : Target +>a5 : (x?: T, y?: T) => T + } +} + +module GenericSignaturesValid { +>GenericSignaturesValid : typeof GenericSignaturesValid + + class Base2 { +>Base2 : Base2 + + a: () => T; +>a : () => T +>T : T +>T : T + + a2: (x?: T) => T; +>a2 : (x?: T) => T +>T : T +>x : T +>T : T +>T : T + + a3: (x: T) => T; +>a3 : (x: T) => T +>T : T +>x : T +>T : T +>T : T + + a4: (x: T, y?: T) => T; +>a4 : (x: T, y?: T) => T +>T : T +>x : T +>T : T +>y : T +>T : T +>T : T + + a5: (x?: T, y?: T) => T; +>a5 : (x?: T, y?: T) => T +>T : T +>x : T +>T : T +>y : T +>T : T +>T : T + + init = () => { +>init : () => void +>() => { 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 } : () => void + + this.a = () => null; // ok, same T of required params +>this.a = () => null : () => any +>this.a : () => T +>this : this +>a : () => T +>() => null : () => any +>T : T +>null : null + + this.a = (x?: T) => null; // ok, same T of required params +>this.a = (x?: T) => null : (x?: T) => any +>this.a : () => T +>this : this +>a : () => T +>(x?: T) => null : (x?: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a = (x: T) => null; // error, too many required params +>this.a = (x: T) => null : (x: T) => any +>this.a : () => T +>this : this +>a : () => T +>(x: T) => null : (x: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a2 = () => null; // ok, same T of required params +>this.a2 = () => null : () => any +>this.a2 : (x?: T) => T +>this : this +>a2 : (x?: T) => T +>() => null : () => any +>T : T +>null : null + + this.a2 = (x?: T) => null; // ok, same T of required params +>this.a2 = (x?: T) => null : (x?: T) => any +>this.a2 : (x?: T) => T +>this : this +>a2 : (x?: T) => T +>(x?: T) => null : (x?: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a2 = (x: T) => null; // ok, same number of params +>this.a2 = (x: T) => null : (x: T) => any +>this.a2 : (x?: T) => T +>this : this +>a2 : (x?: T) => T +>(x: T) => null : (x: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a3 = () => null; // ok, fewer required params +>this.a3 = () => null : () => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>() => null : () => any +>T : T +>null : null + + this.a3 = (x?: T) => null; // ok, fewer required params +>this.a3 = (x?: T) => null : (x?: T) => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>(x?: T) => null : (x?: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a3 = (x: T) => null; // ok, same T of required params +>this.a3 = (x: T) => null : (x: T) => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>(x: T) => null : (x: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a3 = (x: T, y: T) => null; // error, too many required params +>this.a3 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a3 : (x: T) => T +>this : this +>a3 : (x: T) => T +>(x: T, y: T) => null : (x: T, y: T) => any +>T : T +>x : T +>T : T +>y : T +>T : T +>null : null + + this.a4 = () => null; // ok, fewer required params +>this.a4 = () => null : () => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>() => null : () => any +>T : T +>null : null + + this.a4 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a4 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>(x?: T, y?: T) => null : (x?: T, y?: T) => any +>T : T +>x : T +>T : T +>y : T +>T : T +>null : null + + this.a4 = (x: T) => null; // ok, same T of required params +>this.a4 = (x: T) => null : (x: T) => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>(x: T) => null : (x: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a4 = (x: T, y: T) => null; // ok, same number of params +>this.a4 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a4 : (x: T, y?: T) => T +>this : this +>a4 : (x: T, y?: T) => T +>(x: T, y: T) => null : (x: T, y: T) => any +>T : T +>x : T +>T : T +>y : T +>T : T +>null : null + + + this.a5 = () => null; // ok, fewer required params +>this.a5 = () => null : () => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>() => null : () => any +>T : T +>null : null + + this.a5 = (x?: T, y?: T) => null; // ok, fewer required params +>this.a5 = (x?: T, y?: T) => null : (x?: T, y?: T) => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>(x?: T, y?: T) => null : (x?: T, y?: T) => any +>T : T +>x : T +>T : T +>y : T +>T : T +>null : null + + this.a5 = (x: T) => null; // ok, all present params match +>this.a5 = (x: T) => null : (x: T) => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>(x: T) => null : (x: T) => any +>T : T +>x : T +>T : T +>null : null + + this.a5 = (x: T, y: T) => null; // ok, same number of params +>this.a5 = (x: T, y: T) => null : (x: T, y: T) => any +>this.a5 : (x?: T, y?: T) => T +>this : this +>a5 : (x?: T, y?: T) => T +>(x: T, y: T) => null : (x: T, y: T) => any +>T : T +>x : T +>T : T +>y : T +>T : T +>null : null + } + } +} diff --git a/tests/baselines/reference/assignmentCompatWithNumericIndexer.symbols b/tests/baselines/reference/assignmentCompatWithNumericIndexer.symbols new file mode 100644 index 00000000000..106d8a9351d --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithNumericIndexer.symbols @@ -0,0 +1,128 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithNumericIndexer.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithNumericIndexer.ts, 2, 16)) + +interface Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer.ts, 2, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithNumericIndexer.ts, 3, 32)) + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer.ts, 3, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer.ts, 2, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithNumericIndexer.ts, 4, 36)) + +class A { +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer.ts, 4, 51)) + + [x: number]: Base; +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 7, 5)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer.ts, 0, 0)) +} + +var a: A; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 10, 3)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer.ts, 4, 51)) + +var b: { [x: number]: Derived; } +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer.ts, 11, 3)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 11, 10)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer.ts, 2, 31)) + +a = b; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 10, 3)) +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer.ts, 11, 3)) + +b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer.ts, 11, 3)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 10, 3)) + +var b2: { [x: number]: Derived2; } +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer.ts, 15, 3)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 15, 11)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer.ts, 3, 47)) + +a = b2; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 10, 3)) +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer.ts, 15, 3)) + +b2 = a; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer.ts, 15, 3)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 10, 3)) + +module Generics { +>Generics : Symbol(Generics, Decl(assignmentCompatWithNumericIndexer.ts, 17, 7)) + + class A { +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer.ts, 19, 17)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer.ts, 20, 12)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer.ts, 0, 0)) + + [x: number]: T; +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 21, 9)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer.ts, 20, 12)) + } + + class B extends A { +>B : Symbol(B, Decl(assignmentCompatWithNumericIndexer.ts, 22, 5)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer.ts, 19, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer.ts, 0, 0)) + + [x: number]: Derived; // ok +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 25, 9)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer.ts, 2, 31)) + } + + function foo() { +>foo : Symbol(foo, Decl(assignmentCompatWithNumericIndexer.ts, 26, 5)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer.ts, 28, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer.ts, 0, 0)) + + var a: A; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 29, 11)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer.ts, 19, 17)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer.ts, 28, 17)) + + var b: { [x: number]: Derived; } +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer.ts, 30, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 30, 18)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer.ts, 2, 31)) + + a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 29, 11)) +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer.ts, 30, 11)) + + b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer.ts, 30, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 29, 11)) + + var b2: { [x: number]: Derived2; } +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer.ts, 34, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 34, 19)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer.ts, 3, 47)) + + a = b2; // error +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 29, 11)) +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer.ts, 34, 11)) + + b2 = a; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer.ts, 34, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 29, 11)) + + var b3: { [x: number]: T; } +>b3 : Symbol(b3, Decl(assignmentCompatWithNumericIndexer.ts, 38, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer.ts, 38, 19)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer.ts, 28, 17)) + + a = b3; // ok +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 29, 11)) +>b3 : Symbol(b3, Decl(assignmentCompatWithNumericIndexer.ts, 38, 11)) + + b3 = a; // ok +>b3 : Symbol(b3, Decl(assignmentCompatWithNumericIndexer.ts, 38, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer.ts, 29, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithNumericIndexer.types b/tests/baselines/reference/assignmentCompatWithNumericIndexer.types new file mode 100644 index 00000000000..b1d61b0d71e --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithNumericIndexer.types @@ -0,0 +1,138 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithNumericIndexer.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Base +>foo : string + +interface Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +class A { +>A : A + + [x: number]: Base; +>x : number +>Base : Base +} + +var a: A; +>a : A +>A : A + +var b: { [x: number]: Derived; } +>b : { [x: number]: Derived; } +>x : number +>Derived : Derived + +a = b; +>a = b : { [x: number]: Derived; } +>a : A +>b : { [x: number]: Derived; } + +b = a; // error +>b = a : A +>b : { [x: number]: Derived; } +>a : A + +var b2: { [x: number]: Derived2; } +>b2 : { [x: number]: Derived2; } +>x : number +>Derived2 : Derived2 + +a = b2; +>a = b2 : { [x: number]: Derived2; } +>a : A +>b2 : { [x: number]: Derived2; } + +b2 = a; // error +>b2 = a : A +>b2 : { [x: number]: Derived2; } +>a : A + +module Generics { +>Generics : typeof Generics + + class A { +>A : A +>T : T +>Base : Base + + [x: number]: T; +>x : number +>T : T + } + + class B extends A { +>B : B +>A : A +>Base : Base + + [x: number]: Derived; // ok +>x : number +>Derived : Derived + } + + function foo() { +>foo : () => void +>T : T +>Base : Base + + var a: A; +>a : A +>A : A +>T : T + + var b: { [x: number]: Derived; } +>b : { [x: number]: Derived; } +>x : number +>Derived : Derived + + a = b; // error +>a = b : { [x: number]: Derived; } +>a : A +>b : { [x: number]: Derived; } + + b = a; // error +>b = a : A +>b : { [x: number]: Derived; } +>a : A + + var b2: { [x: number]: Derived2; } +>b2 : { [x: number]: Derived2; } +>x : number +>Derived2 : Derived2 + + a = b2; // error +>a = b2 : { [x: number]: Derived2; } +>a : A +>b2 : { [x: number]: Derived2; } + + b2 = a; // error +>b2 = a : A +>b2 : { [x: number]: Derived2; } +>a : A + + var b3: { [x: number]: T; } +>b3 : { [x: number]: T; } +>x : number +>T : T + + a = b3; // ok +>a = b3 : { [x: number]: T; } +>a : A +>b3 : { [x: number]: T; } + + b3 = a; // ok +>b3 = a : A +>b3 : { [x: number]: T; } +>a : A + } +} diff --git a/tests/baselines/reference/assignmentCompatWithNumericIndexer2.symbols b/tests/baselines/reference/assignmentCompatWithNumericIndexer2.symbols new file mode 100644 index 00000000000..c1b9bd26f9d --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithNumericIndexer2.symbols @@ -0,0 +1,128 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithNumericIndexer2.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer2.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithNumericIndexer2.ts, 2, 16)) + +interface Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer2.ts, 2, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer2.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithNumericIndexer2.ts, 3, 32)) + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer2.ts, 3, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer2.ts, 2, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithNumericIndexer2.ts, 4, 36)) + +interface A { +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer2.ts, 4, 51)) + + [x: number]: Base; +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 7, 5)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer2.ts, 0, 0)) +} + +var a: A; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 10, 3)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer2.ts, 4, 51)) + +var b: { [x: number]: Derived; } +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer2.ts, 11, 3)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 11, 10)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer2.ts, 2, 31)) + +a = b; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 10, 3)) +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer2.ts, 11, 3)) + +b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer2.ts, 11, 3)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 10, 3)) + +var b2: { [x: number]: Derived2; } +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer2.ts, 15, 3)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 15, 11)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer2.ts, 3, 47)) + +a = b2; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 10, 3)) +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer2.ts, 15, 3)) + +b2 = a; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer2.ts, 15, 3)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 10, 3)) + +module Generics { +>Generics : Symbol(Generics, Decl(assignmentCompatWithNumericIndexer2.ts, 17, 7)) + + interface A { +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer2.ts, 19, 17)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer2.ts, 20, 16)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer2.ts, 0, 0)) + + [x: number]: T; +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 21, 9)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer2.ts, 20, 16)) + } + + interface B extends A { +>B : Symbol(B, Decl(assignmentCompatWithNumericIndexer2.ts, 22, 5)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer2.ts, 19, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer2.ts, 0, 0)) + + [x: number]: Derived; // ok +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 25, 9)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer2.ts, 2, 31)) + } + + function foo() { +>foo : Symbol(foo, Decl(assignmentCompatWithNumericIndexer2.ts, 26, 5)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer2.ts, 28, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer2.ts, 0, 0)) + + var a: A; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 29, 11)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer2.ts, 19, 17)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer2.ts, 28, 17)) + + var b: { [x: number]: Derived; } +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer2.ts, 30, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 30, 18)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer2.ts, 2, 31)) + + a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 29, 11)) +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer2.ts, 30, 11)) + + b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer2.ts, 30, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 29, 11)) + + var b2: { [x: number]: Derived2; } +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer2.ts, 34, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 34, 19)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer2.ts, 3, 47)) + + a = b2; // error +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 29, 11)) +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer2.ts, 34, 11)) + + b2 = a; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer2.ts, 34, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 29, 11)) + + var b3: { [x: number]: T; } +>b3 : Symbol(b3, Decl(assignmentCompatWithNumericIndexer2.ts, 38, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer2.ts, 38, 19)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer2.ts, 28, 17)) + + a = b3; // ok +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 29, 11)) +>b3 : Symbol(b3, Decl(assignmentCompatWithNumericIndexer2.ts, 38, 11)) + + b3 = a; // ok +>b3 : Symbol(b3, Decl(assignmentCompatWithNumericIndexer2.ts, 38, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer2.ts, 29, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithNumericIndexer2.types b/tests/baselines/reference/assignmentCompatWithNumericIndexer2.types new file mode 100644 index 00000000000..c980c8ef9ea --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithNumericIndexer2.types @@ -0,0 +1,138 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithNumericIndexer2.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Base +>foo : string + +interface Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +interface A { +>A : A + + [x: number]: Base; +>x : number +>Base : Base +} + +var a: A; +>a : A +>A : A + +var b: { [x: number]: Derived; } +>b : { [x: number]: Derived; } +>x : number +>Derived : Derived + +a = b; +>a = b : { [x: number]: Derived; } +>a : A +>b : { [x: number]: Derived; } + +b = a; // error +>b = a : A +>b : { [x: number]: Derived; } +>a : A + +var b2: { [x: number]: Derived2; } +>b2 : { [x: number]: Derived2; } +>x : number +>Derived2 : Derived2 + +a = b2; +>a = b2 : { [x: number]: Derived2; } +>a : A +>b2 : { [x: number]: Derived2; } + +b2 = a; // error +>b2 = a : A +>b2 : { [x: number]: Derived2; } +>a : A + +module Generics { +>Generics : typeof Generics + + interface A { +>A : A +>T : T +>Base : Base + + [x: number]: T; +>x : number +>T : T + } + + interface B extends A { +>B : B +>A : A +>Base : Base + + [x: number]: Derived; // ok +>x : number +>Derived : Derived + } + + function foo() { +>foo : () => void +>T : T +>Base : Base + + var a: A; +>a : A +>A : A +>T : T + + var b: { [x: number]: Derived; } +>b : { [x: number]: Derived; } +>x : number +>Derived : Derived + + a = b; // error +>a = b : { [x: number]: Derived; } +>a : A +>b : { [x: number]: Derived; } + + b = a; // error +>b = a : A +>b : { [x: number]: Derived; } +>a : A + + var b2: { [x: number]: Derived2; } +>b2 : { [x: number]: Derived2; } +>x : number +>Derived2 : Derived2 + + a = b2; // error +>a = b2 : { [x: number]: Derived2; } +>a : A +>b2 : { [x: number]: Derived2; } + + b2 = a; // error +>b2 = a : A +>b2 : { [x: number]: Derived2; } +>a : A + + var b3: { [x: number]: T; } +>b3 : { [x: number]: T; } +>x : number +>T : T + + a = b3; // ok +>a = b3 : { [x: number]: T; } +>a : A +>b3 : { [x: number]: T; } + + b3 = a; // ok +>b3 = a : A +>b3 : { [x: number]: T; } +>a : A + } +} diff --git a/tests/baselines/reference/assignmentCompatWithNumericIndexer3.symbols b/tests/baselines/reference/assignmentCompatWithNumericIndexer3.symbols new file mode 100644 index 00000000000..133f0e9ef12 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithNumericIndexer3.symbols @@ -0,0 +1,114 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithNumericIndexer3.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer3.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithNumericIndexer3.ts, 2, 16)) + +interface Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer3.ts, 2, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer3.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithNumericIndexer3.ts, 3, 32)) + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer3.ts, 3, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer3.ts, 2, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithNumericIndexer3.ts, 4, 36)) + +class A { +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer3.ts, 4, 51)) + + [x: number]: Derived; +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer3.ts, 7, 5)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer3.ts, 2, 31)) +} + +var a: A; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 10, 3)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer3.ts, 4, 51)) + +var b: { [x: number]: Base; }; +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer3.ts, 11, 3)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer3.ts, 11, 10)) +>Base : Symbol(Base, Decl(assignmentCompatWithNumericIndexer3.ts, 0, 0)) + +a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 10, 3)) +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer3.ts, 11, 3)) + +b = a; // ok +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer3.ts, 11, 3)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 10, 3)) + +class B2 extends A { +>B2 : Symbol(B2, Decl(assignmentCompatWithNumericIndexer3.ts, 14, 6)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer3.ts, 4, 51)) + + [x: number]: Derived2; // ok +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer3.ts, 17, 5)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer3.ts, 3, 47)) +} + +var b2: { [x: number]: Derived2; }; +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer3.ts, 20, 3)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer3.ts, 20, 11)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithNumericIndexer3.ts, 3, 47)) + +a = b2; // ok +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 10, 3)) +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer3.ts, 20, 3)) + +b2 = a; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer3.ts, 20, 3)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 10, 3)) + +module Generics { +>Generics : Symbol(Generics, Decl(assignmentCompatWithNumericIndexer3.ts, 22, 7)) + + class A { +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer3.ts, 24, 17)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer3.ts, 25, 12)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer3.ts, 2, 31)) + + [x: number]: T; +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer3.ts, 26, 9)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer3.ts, 25, 12)) + } + + function foo() { +>foo : Symbol(foo, Decl(assignmentCompatWithNumericIndexer3.ts, 27, 5)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer3.ts, 29, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer3.ts, 2, 31)) + + var a: A; +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 30, 11)) +>A : Symbol(A, Decl(assignmentCompatWithNumericIndexer3.ts, 24, 17)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer3.ts, 29, 17)) + + var b: { [x: number]: Derived; }; +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer3.ts, 31, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer3.ts, 31, 18)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithNumericIndexer3.ts, 2, 31)) + + a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 30, 11)) +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer3.ts, 31, 11)) + + b = a; // ok +>b : Symbol(b, Decl(assignmentCompatWithNumericIndexer3.ts, 31, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 30, 11)) + + var b2: { [x: number]: T; }; +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer3.ts, 35, 11)) +>x : Symbol(x, Decl(assignmentCompatWithNumericIndexer3.ts, 35, 19)) +>T : Symbol(T, Decl(assignmentCompatWithNumericIndexer3.ts, 29, 17)) + + a = b2; // ok +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 30, 11)) +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer3.ts, 35, 11)) + + b2 = a; // ok +>b2 : Symbol(b2, Decl(assignmentCompatWithNumericIndexer3.ts, 35, 11)) +>a : Symbol(a, Decl(assignmentCompatWithNumericIndexer3.ts, 30, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithNumericIndexer3.types b/tests/baselines/reference/assignmentCompatWithNumericIndexer3.types new file mode 100644 index 00000000000..3f7b0549254 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithNumericIndexer3.types @@ -0,0 +1,122 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithNumericIndexer3.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Base +>foo : string + +interface Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +class A { +>A : A + + [x: number]: Derived; +>x : number +>Derived : Derived +} + +var a: A; +>a : A +>A : A + +var b: { [x: number]: Base; }; +>b : { [x: number]: Base; } +>x : number +>Base : Base + +a = b; // error +>a = b : { [x: number]: Base; } +>a : A +>b : { [x: number]: Base; } + +b = a; // ok +>b = a : A +>b : { [x: number]: Base; } +>a : A + +class B2 extends A { +>B2 : B2 +>A : A + + [x: number]: Derived2; // ok +>x : number +>Derived2 : Derived2 +} + +var b2: { [x: number]: Derived2; }; +>b2 : { [x: number]: Derived2; } +>x : number +>Derived2 : Derived2 + +a = b2; // ok +>a = b2 : { [x: number]: Derived2; } +>a : A +>b2 : { [x: number]: Derived2; } + +b2 = a; // error +>b2 = a : A +>b2 : { [x: number]: Derived2; } +>a : A + +module Generics { +>Generics : typeof Generics + + class A { +>A : A +>T : T +>Derived : Derived + + [x: number]: T; +>x : number +>T : T + } + + function foo() { +>foo : () => void +>T : T +>Derived : Derived + + var a: A; +>a : A +>A : A +>T : T + + var b: { [x: number]: Derived; }; +>b : { [x: number]: Derived; } +>x : number +>Derived : Derived + + a = b; // error +>a = b : { [x: number]: Derived; } +>a : A +>b : { [x: number]: Derived; } + + b = a; // ok +>b = a : A +>b : { [x: number]: Derived; } +>a : A + + var b2: { [x: number]: T; }; +>b2 : { [x: number]: T; } +>x : number +>T : T + + a = b2; // ok +>a = b2 : { [x: number]: T; } +>a : A +>b2 : { [x: number]: T; } + + b2 = a; // ok +>b2 = a : A +>b2 : { [x: number]: T; } +>a : A + } +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers4.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers4.symbols new file mode 100644 index 00000000000..845747216f8 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembers4.symbols @@ -0,0 +1,302 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembers4.ts === +// 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 { +>OnlyDerived : Symbol(OnlyDerived, Decl(assignmentCompatWithObjectMembers4.ts, 0, 0)) + + class Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 2, 20)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithObjectMembers4.ts, 3, 16)) + + class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembers4.ts, 3, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 2, 20)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithObjectMembers4.ts, 4, 32)) + + class Derived2 extends Base { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 4, 47)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 2, 20)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithObjectMembers4.ts, 5, 33)) + + class S { foo: Derived; } +>S : Symbol(S, Decl(assignmentCompatWithObjectMembers4.ts, 5, 48)) +>foo : Symbol(S.foo, Decl(assignmentCompatWithObjectMembers4.ts, 7, 13)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembers4.ts, 3, 31)) + + class T { foo: Derived2; } +>T : Symbol(T, Decl(assignmentCompatWithObjectMembers4.ts, 7, 29)) +>foo : Symbol(T.foo, Decl(assignmentCompatWithObjectMembers4.ts, 8, 13)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 4, 47)) + + var s: S; +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 9, 7)) +>S : Symbol(S, Decl(assignmentCompatWithObjectMembers4.ts, 5, 48)) + + var t: T; +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 10, 7)) +>T : Symbol(T, Decl(assignmentCompatWithObjectMembers4.ts, 7, 29)) + + interface S2 { foo: Derived; } +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers4.ts, 10, 13)) +>foo : Symbol(S2.foo, Decl(assignmentCompatWithObjectMembers4.ts, 12, 18)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembers4.ts, 3, 31)) + + interface T2 { foo: Derived2; } +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers4.ts, 12, 34)) +>foo : Symbol(T2.foo, Decl(assignmentCompatWithObjectMembers4.ts, 13, 18)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 4, 47)) + + var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers4.ts, 10, 13)) + + var t2: T2; +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 15, 7)) +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers4.ts, 12, 34)) + + var a: { foo: Derived; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 17, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 17, 12)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembers4.ts, 3, 31)) + + var b: { foo: Derived2; } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 18, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 18, 12)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 4, 47)) + + var a2 = { foo: new Derived() }; +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 20, 14)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembers4.ts, 3, 31)) + + var b2 = { foo: new Derived2() }; +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers4.ts, 21, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 21, 14)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 4, 47)) + + s = t; // error +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 9, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 10, 7)) + + t = s; // error +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 10, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 9, 7)) + + s = s2; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 9, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) + + s = a2; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 9, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) + + s2 = t2; // error +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 15, 7)) + + t2 = s2; // error +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 15, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) + + s2 = t; // error +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 10, 7)) + + s2 = b; // error +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 18, 7)) + + s2 = a2; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) + + a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 17, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 18, 7)) + + b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 18, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 17, 7)) + + a = s; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 17, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 9, 7)) + + a = s2; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 17, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 14, 7)) + + a = a2; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 17, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) + + a2 = b2; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers4.ts, 21, 7)) + + b2 = a2; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers4.ts, 21, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) + + a2 = b; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 18, 7)) + + a2 = t2; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 15, 7)) + + a2 = t; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 20, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 10, 7)) +} + +module WithBase { +>WithBase : Symbol(WithBase, Decl(assignmentCompatWithObjectMembers4.ts, 45, 1)) + + class Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 47, 17)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithObjectMembers4.ts, 48, 16)) + + class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembers4.ts, 48, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 47, 17)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithObjectMembers4.ts, 49, 32)) + + class Derived2 extends Base { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 49, 47)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 47, 17)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithObjectMembers4.ts, 50, 33)) + + class S { foo: Base; } +>S : Symbol(S, Decl(assignmentCompatWithObjectMembers4.ts, 50, 48)) +>foo : Symbol(S.foo, Decl(assignmentCompatWithObjectMembers4.ts, 52, 13)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 47, 17)) + + class T { foo: Derived2; } +>T : Symbol(T, Decl(assignmentCompatWithObjectMembers4.ts, 52, 26)) +>foo : Symbol(T.foo, Decl(assignmentCompatWithObjectMembers4.ts, 53, 13)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 49, 47)) + + var s: S; +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 54, 7)) +>S : Symbol(S, Decl(assignmentCompatWithObjectMembers4.ts, 50, 48)) + + var t: T; +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 55, 7)) +>T : Symbol(T, Decl(assignmentCompatWithObjectMembers4.ts, 52, 26)) + + interface S2 { foo: Base; } +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers4.ts, 55, 13)) +>foo : Symbol(S2.foo, Decl(assignmentCompatWithObjectMembers4.ts, 57, 18)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 47, 17)) + + interface T2 { foo: Derived2; } +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers4.ts, 57, 31)) +>foo : Symbol(T2.foo, Decl(assignmentCompatWithObjectMembers4.ts, 58, 18)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 49, 47)) + + var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembers4.ts, 55, 13)) + + var t2: T2; +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 60, 7)) +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembers4.ts, 57, 31)) + + var a: { foo: Base; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 62, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 62, 12)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 47, 17)) + + var b: { foo: Derived2; } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 63, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 63, 12)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 49, 47)) + + var a2 = { foo: new Base() }; +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 65, 14)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembers4.ts, 47, 17)) + + var b2 = { foo: new Derived2() }; +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers4.ts, 66, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembers4.ts, 66, 14)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembers4.ts, 49, 47)) + + s = t; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 54, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 55, 7)) + + t = s; // error +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 55, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 54, 7)) + + s = s2; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 54, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) + + s = a2; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 54, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) + + s2 = t2; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 60, 7)) + + t2 = s2; // error +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 60, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) + + s2 = t; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 55, 7)) + + s2 = b; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 63, 7)) + + s2 = a2; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) + + a = b; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 62, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 63, 7)) + + b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 63, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 62, 7)) + + a = s; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 62, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembers4.ts, 54, 7)) + + a = s2; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 62, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembers4.ts, 59, 7)) + + a = a2; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembers4.ts, 62, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) + + a2 = b2; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers4.ts, 66, 7)) + + b2 = a2; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembers4.ts, 66, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) + + a2 = b; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembers4.ts, 63, 7)) + + a2 = t2; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembers4.ts, 60, 7)) + + a2 = t; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembers4.ts, 65, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembers4.ts, 55, 7)) +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers4.types b/tests/baselines/reference/assignmentCompatWithObjectMembers4.types new file mode 100644 index 00000000000..1d7fb3eae7b --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembers4.types @@ -0,0 +1,348 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembers4.ts === +// 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 { +>OnlyDerived : typeof OnlyDerived + + class Base { foo: string; } +>Base : Base +>foo : string + + class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + + class Derived2 extends Base { baz: string; } +>Derived2 : Derived2 +>Base : Base +>baz : string + + class S { foo: Derived; } +>S : S +>foo : Derived +>Derived : Derived + + class T { foo: Derived2; } +>T : T +>foo : Derived2 +>Derived2 : Derived2 + + var s: S; +>s : S +>S : S + + var t: T; +>t : T +>T : T + + interface S2 { foo: Derived; } +>S2 : S2 +>foo : Derived +>Derived : Derived + + interface T2 { foo: Derived2; } +>T2 : T2 +>foo : Derived2 +>Derived2 : Derived2 + + var s2: S2; +>s2 : S2 +>S2 : S2 + + var t2: T2; +>t2 : T2 +>T2 : T2 + + var a: { foo: Derived; } +>a : { foo: Derived; } +>foo : Derived +>Derived : Derived + + var b: { foo: Derived2; } +>b : { foo: Derived2; } +>foo : Derived2 +>Derived2 : Derived2 + + var a2 = { foo: new Derived() }; +>a2 : { foo: Derived; } +>{ foo: new Derived() } : { foo: Derived; } +>foo : Derived +>new Derived() : Derived +>Derived : typeof Derived + + var b2 = { foo: new Derived2() }; +>b2 : { foo: Derived2; } +>{ foo: new Derived2() } : { foo: Derived2; } +>foo : Derived2 +>new Derived2() : Derived2 +>Derived2 : typeof Derived2 + + s = t; // error +>s = t : T +>s : S +>t : T + + t = s; // error +>t = s : S +>t : T +>s : S + + s = s2; // ok +>s = s2 : S2 +>s : S +>s2 : S2 + + s = a2; // ok +>s = a2 : { foo: Derived; } +>s : S +>a2 : { foo: Derived; } + + s2 = t2; // error +>s2 = t2 : T2 +>s2 : S2 +>t2 : T2 + + t2 = s2; // error +>t2 = s2 : S2 +>t2 : T2 +>s2 : S2 + + s2 = t; // error +>s2 = t : T +>s2 : S2 +>t : T + + s2 = b; // error +>s2 = b : { foo: Derived2; } +>s2 : S2 +>b : { foo: Derived2; } + + s2 = a2; // ok +>s2 = a2 : { foo: Derived; } +>s2 : S2 +>a2 : { foo: Derived; } + + a = b; // error +>a = b : { foo: Derived2; } +>a : { foo: Derived; } +>b : { foo: Derived2; } + + b = a; // error +>b = a : { foo: Derived; } +>b : { foo: Derived2; } +>a : { foo: Derived; } + + a = s; // ok +>a = s : S +>a : { foo: Derived; } +>s : S + + a = s2; // ok +>a = s2 : S2 +>a : { foo: Derived; } +>s2 : S2 + + a = a2; // ok +>a = a2 : { foo: Derived; } +>a : { foo: Derived; } +>a2 : { foo: Derived; } + + a2 = b2; // error +>a2 = b2 : { foo: Derived2; } +>a2 : { foo: Derived; } +>b2 : { foo: Derived2; } + + b2 = a2; // error +>b2 = a2 : { foo: Derived; } +>b2 : { foo: Derived2; } +>a2 : { foo: Derived; } + + a2 = b; // error +>a2 = b : { foo: Derived2; } +>a2 : { foo: Derived; } +>b : { foo: Derived2; } + + a2 = t2; // error +>a2 = t2 : T2 +>a2 : { foo: Derived; } +>t2 : T2 + + a2 = t; // error +>a2 = t : T +>a2 : { foo: Derived; } +>t : T +} + +module WithBase { +>WithBase : typeof WithBase + + class Base { foo: string; } +>Base : Base +>foo : string + + class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + + class Derived2 extends Base { baz: string; } +>Derived2 : Derived2 +>Base : Base +>baz : string + + class S { foo: Base; } +>S : S +>foo : Base +>Base : Base + + class T { foo: Derived2; } +>T : T +>foo : Derived2 +>Derived2 : Derived2 + + var s: S; +>s : S +>S : S + + var t: T; +>t : T +>T : T + + interface S2 { foo: Base; } +>S2 : S2 +>foo : Base +>Base : Base + + interface T2 { foo: Derived2; } +>T2 : T2 +>foo : Derived2 +>Derived2 : Derived2 + + var s2: S2; +>s2 : S2 +>S2 : S2 + + var t2: T2; +>t2 : T2 +>T2 : T2 + + var a: { foo: Base; } +>a : { foo: Base; } +>foo : Base +>Base : Base + + var b: { foo: Derived2; } +>b : { foo: Derived2; } +>foo : Derived2 +>Derived2 : Derived2 + + var a2 = { foo: new Base() }; +>a2 : { foo: Base; } +>{ foo: new Base() } : { foo: Base; } +>foo : Base +>new Base() : Base +>Base : typeof Base + + var b2 = { foo: new Derived2() }; +>b2 : { foo: Derived2; } +>{ foo: new Derived2() } : { foo: Derived2; } +>foo : Derived2 +>new Derived2() : Derived2 +>Derived2 : typeof Derived2 + + s = t; // ok +>s = t : T +>s : S +>t : T + + t = s; // error +>t = s : S +>t : T +>s : S + + s = s2; // ok +>s = s2 : S2 +>s : S +>s2 : S2 + + s = a2; // ok +>s = a2 : { foo: Base; } +>s : S +>a2 : { foo: Base; } + + s2 = t2; // ok +>s2 = t2 : T2 +>s2 : S2 +>t2 : T2 + + t2 = s2; // error +>t2 = s2 : S2 +>t2 : T2 +>s2 : S2 + + s2 = t; // ok +>s2 = t : T +>s2 : S2 +>t : T + + s2 = b; // ok +>s2 = b : { foo: Derived2; } +>s2 : S2 +>b : { foo: Derived2; } + + s2 = a2; // ok +>s2 = a2 : { foo: Base; } +>s2 : S2 +>a2 : { foo: Base; } + + a = b; // ok +>a = b : { foo: Derived2; } +>a : { foo: Base; } +>b : { foo: Derived2; } + + b = a; // error +>b = a : { foo: Base; } +>b : { foo: Derived2; } +>a : { foo: Base; } + + a = s; // ok +>a = s : S +>a : { foo: Base; } +>s : S + + a = s2; // ok +>a = s2 : S2 +>a : { foo: Base; } +>s2 : S2 + + a = a2; // ok +>a = a2 : { foo: Base; } +>a : { foo: Base; } +>a2 : { foo: Base; } + + a2 = b2; // ok +>a2 = b2 : { foo: Derived2; } +>a2 : { foo: Base; } +>b2 : { foo: Derived2; } + + b2 = a2; // error +>b2 = a2 : { foo: Base; } +>b2 : { foo: Derived2; } +>a2 : { foo: Base; } + + a2 = b; // ok +>a2 = b : { foo: Derived2; } +>a2 : { foo: Base; } +>b : { foo: Derived2; } + + a2 = t2; // ok +>a2 = t2 : T2 +>a2 : { foo: Base; } +>t2 : T2 + + a2 = t; // ok +>a2 = t : T +>a2 : { foo: Base; } +>t : T +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers5.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembers5.symbols new file mode 100644 index 00000000000..541f2b72b58 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembers5.symbols @@ -0,0 +1,31 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembers5.ts === +class C { +>C : Symbol(C, Decl(assignmentCompatWithObjectMembers5.ts, 0, 0)) + + foo: string; +>foo : Symbol(C.foo, Decl(assignmentCompatWithObjectMembers5.ts, 0, 9)) +} + +var c: C; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembers5.ts, 4, 3)) +>C : Symbol(C, Decl(assignmentCompatWithObjectMembers5.ts, 0, 0)) + +interface I { +>I : Symbol(I, Decl(assignmentCompatWithObjectMembers5.ts, 4, 9)) + + fooo: string; +>fooo : Symbol(I.fooo, Decl(assignmentCompatWithObjectMembers5.ts, 6, 13)) +} + +var i: I; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembers5.ts, 10, 3)) +>I : Symbol(I, Decl(assignmentCompatWithObjectMembers5.ts, 4, 9)) + +c = i; // error +>c : Symbol(c, Decl(assignmentCompatWithObjectMembers5.ts, 4, 3)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembers5.ts, 10, 3)) + +i = c; // error +>i : Symbol(i, Decl(assignmentCompatWithObjectMembers5.ts, 10, 3)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembers5.ts, 4, 3)) + diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembers5.types b/tests/baselines/reference/assignmentCompatWithObjectMembers5.types new file mode 100644 index 00000000000..87c213ff0fd --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembers5.types @@ -0,0 +1,33 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembers5.ts === +class C { +>C : C + + foo: string; +>foo : string +} + +var c: C; +>c : C +>C : C + +interface I { +>I : I + + fooo: string; +>fooo : string +} + +var i: I; +>i : I +>I : I + +c = i; // error +>c = i : I +>c : C +>i : I + +i = c; // error +>i = c : C +>i : I +>c : C + diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.symbols new file mode 100644 index 00000000000..f1ec2133314 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.symbols @@ -0,0 +1,285 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersAccessibility.ts === +// members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M + +module TargetIsPublic { +>TargetIsPublic : Symbol(TargetIsPublic, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 0, 0), Decl(assignmentCompatWithObjectMembersAccessibility.ts, 53, 1)) + + // targets + class Base { +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 2, 23)) + + public foo: string; +>foo : Symbol(Base.foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 4, 16)) + } + + interface I { +>I : Symbol(I, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 6, 5)) + + foo: string; +>foo : Symbol(I.foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 8, 17)) + } + + var a: { foo: string; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 12)) + + var b: Base; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 2, 23)) + + var i: I; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) +>I : Symbol(I, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 6, 5)) + + // sources + class D { +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 13)) + + public foo: string; +>foo : Symbol(D.foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 17, 13)) + } + + class E { +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 19, 5)) + + private foo: string; +>foo : Symbol(E.foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 21, 13)) + } + var d: D; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 13)) + + var e: E; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 19, 5)) + + a = b; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) + + a = i; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) + + a = d; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) + + a = e; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) + + b = a; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) + + b = i; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) + + b = d; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) + + b = e; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) + + i = a; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) + + i = b; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) + + i = d; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) + + i = e; // error +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) + + d = a; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) + + d = b; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) + + d = i; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) + + d = e; // error +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) + + e = a; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 12, 7)) + + e = b; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 13, 7)) + + e = i; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 14, 7)) + + e = d; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 24, 7)) + + e = e; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 25, 7)) + +} + +module TargetIsPublic { +>TargetIsPublic : Symbol(TargetIsPublic, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 0, 0), Decl(assignmentCompatWithObjectMembersAccessibility.ts, 53, 1)) + + // targets + class Base { +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 55, 23)) + + private foo: string; +>foo : Symbol(Base.foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 57, 16)) + } + + interface I extends Base { +>I : Symbol(I, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 59, 5)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 55, 23)) + } + + var a: { foo: string; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) +>foo : Symbol(foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 12)) + + var b: Base; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 55, 23)) + + var i: I; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) +>I : Symbol(I, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 59, 5)) + + // sources + class D { +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 13)) + + public foo: string; +>foo : Symbol(D.foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 69, 13)) + } + + class E { +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 71, 5)) + + private foo: string; +>foo : Symbol(E.foo, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 73, 13)) + } + + var d: D; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 13)) + + var e: E; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 71, 5)) + + a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) + + a = i; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) + + a = d; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) + + a = e; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) + + b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) + + b = i; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) + + b = d; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) + + b = e; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) + + b = b; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) + + i = a; // error +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) + + i = b; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) + + i = d; // error +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) + + i = e; // error +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) + + i = i; +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) + + d = a; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) + + d = b; // error +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) + + d = i; // error +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) + + d = e; // error +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) + + e = a; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 64, 7)) + + e = b; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 65, 7)) + + e = i; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) +>i : Symbol(i, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 66, 7)) + + e = d; // errror +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 77, 7)) + + e = e; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersAccessibility.ts, 78, 7)) + +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.types b/tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.types new file mode 100644 index 00000000000..ec65f474f20 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersAccessibility.types @@ -0,0 +1,329 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersAccessibility.ts === +// members N and M of types S and T have the same name, same accessibility, same optionality, and N is assignable M + +module TargetIsPublic { +>TargetIsPublic : typeof TargetIsPublic + + // targets + class Base { +>Base : Base + + public foo: string; +>foo : string + } + + interface I { +>I : I + + foo: string; +>foo : string + } + + var a: { foo: string; } +>a : { foo: string; } +>foo : string + + var b: Base; +>b : Base +>Base : Base + + var i: I; +>i : I +>I : I + + // sources + class D { +>D : D + + public foo: string; +>foo : string + } + + class E { +>E : E + + private foo: string; +>foo : string + } + var d: D; +>d : D +>D : D + + var e: E; +>e : E +>E : E + + a = b; +>a = b : Base +>a : { foo: string; } +>b : Base + + a = i; +>a = i : I +>a : { foo: string; } +>i : I + + a = d; +>a = d : D +>a : { foo: string; } +>d : D + + a = e; // error +>a = e : E +>a : { foo: string; } +>e : E + + b = a; +>b = a : { foo: string; } +>b : Base +>a : { foo: string; } + + b = i; +>b = i : I +>b : Base +>i : I + + b = d; +>b = d : D +>b : Base +>d : D + + b = e; // error +>b = e : E +>b : Base +>e : E + + i = a; +>i = a : { foo: string; } +>i : I +>a : { foo: string; } + + i = b; +>i = b : Base +>i : I +>b : Base + + i = d; +>i = d : D +>i : I +>d : D + + i = e; // error +>i = e : E +>i : I +>e : E + + d = a; +>d = a : { foo: string; } +>d : D +>a : { foo: string; } + + d = b; +>d = b : Base +>d : D +>b : Base + + d = i; +>d = i : I +>d : D +>i : I + + d = e; // error +>d = e : E +>d : D +>e : E + + e = a; // errror +>e = a : { foo: string; } +>e : E +>a : { foo: string; } + + e = b; // errror +>e = b : Base +>e : E +>b : Base + + e = i; // errror +>e = i : I +>e : E +>i : I + + e = d; // errror +>e = d : D +>e : E +>d : D + + e = e; +>e = e : E +>e : E +>e : E + +} + +module TargetIsPublic { +>TargetIsPublic : typeof TargetIsPublic + + // targets + class Base { +>Base : Base + + private foo: string; +>foo : string + } + + interface I extends Base { +>I : I +>Base : Base + } + + var a: { foo: string; } +>a : { foo: string; } +>foo : string + + var b: Base; +>b : Base +>Base : Base + + var i: I; +>i : I +>I : I + + // sources + class D { +>D : D + + public foo: string; +>foo : string + } + + class E { +>E : E + + private foo: string; +>foo : string + } + + var d: D; +>d : D +>D : D + + var e: E; +>e : E +>E : E + + a = b; // error +>a = b : Base +>a : { foo: string; } +>b : Base + + a = i; // error +>a = i : I +>a : { foo: string; } +>i : I + + a = d; +>a = d : D +>a : { foo: string; } +>d : D + + a = e; // error +>a = e : E +>a : { foo: string; } +>e : E + + b = a; // error +>b = a : { foo: string; } +>b : Base +>a : { foo: string; } + + b = i; +>b = i : I +>b : Base +>i : I + + b = d; // error +>b = d : D +>b : Base +>d : D + + b = e; // error +>b = e : E +>b : Base +>e : E + + b = b; +>b = b : Base +>b : Base +>b : Base + + i = a; // error +>i = a : { foo: string; } +>i : I +>a : { foo: string; } + + i = b; +>i = b : Base +>i : I +>b : Base + + i = d; // error +>i = d : D +>i : I +>d : D + + i = e; // error +>i = e : E +>i : I +>e : E + + i = i; +>i = i : I +>i : I +>i : I + + d = a; +>d = a : { foo: string; } +>d : D +>a : { foo: string; } + + d = b; // error +>d = b : Base +>d : D +>b : Base + + d = i; // error +>d = i : I +>d : D +>i : I + + d = e; // error +>d = e : E +>d : D +>e : E + + e = a; // errror +>e = a : { foo: string; } +>e : E +>a : { foo: string; } + + e = b; // errror +>e = b : Base +>e : E +>b : Base + + e = i; // errror +>e = i : I +>e : E +>i : I + + e = d; // errror +>e = d : D +>e : E +>d : D + + e = e; +>e = e : E +>e : E +>e : E + +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.symbols new file mode 100644 index 00000000000..f3271f0e9c3 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.symbols @@ -0,0 +1,242 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality.ts === +// Derived member is not optional but base member is, should be ok + +class Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithObjectMembersOptionality.ts, 2, 12)) + +class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality.ts, 2, 27)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithObjectMembersOptionality.ts, 3, 28)) + +class Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembersOptionality.ts, 3, 43)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality.ts, 2, 27)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithObjectMembersOptionality.ts, 4, 32)) + +module TargetHasOptional { +>TargetHasOptional : Symbol(TargetHasOptional, Decl(assignmentCompatWithObjectMembersOptionality.ts, 4, 47)) + + // targets + interface C { +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality.ts, 6, 26)) + + opt?: Base +>opt : Symbol(C.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 8, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + } + var c: C; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 11, 7)) +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality.ts, 6, 26)) + + var a: { opt?: Base; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 12)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + + var b: typeof a = { opt: new Base() } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 23)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + + // sources + interface D { +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 41)) + + opt: Base; +>opt : Symbol(D.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 17, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + } + interface E { +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality.ts, 19, 5)) + + opt: Derived; +>opt : Symbol(E.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 20, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality.ts, 2, 27)) + } + interface F { +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality.ts, 22, 5)) + + opt?: Derived; +>opt : Symbol(F.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 23, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality.ts, 2, 27)) + } + var d: D; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 26, 7)) +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 41)) + + var e: E; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 27, 7)) +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality.ts, 19, 5)) + + var f: F; +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 28, 7)) +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality.ts, 22, 5)) + + // all ok + c = d; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 11, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 26, 7)) + + c = e; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 11, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 27, 7)) + + c = f; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 11, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 28, 7)) + + c = a; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 11, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) + + a = d; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 26, 7)) + + a = e; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 27, 7)) + + a = f; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 28, 7)) + + a = c; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 11, 7)) + + b = d; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 26, 7)) + + b = e; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 27, 7)) + + b = f; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 28, 7)) + + b = a; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 13, 7)) + + b = c; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 14, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 11, 7)) +} + +module SourceHasOptional { +>SourceHasOptional : Symbol(SourceHasOptional, Decl(assignmentCompatWithObjectMembersOptionality.ts, 46, 1)) + + // targets + interface C { +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality.ts, 48, 26)) + + opt: Base +>opt : Symbol(C.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 50, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + } + var c: C; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 53, 7)) +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality.ts, 48, 26)) + + var a: { opt: Base; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 12)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + + var b = { opt: new Base() } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 13)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + + // sources + interface D { +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 31)) + + opt?: Base; +>opt : Symbol(D.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 59, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality.ts, 0, 0)) + } + interface E { +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality.ts, 61, 5)) + + opt?: Derived; +>opt : Symbol(E.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 62, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality.ts, 2, 27)) + } + interface F { +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality.ts, 64, 5)) + + opt: Derived; +>opt : Symbol(F.opt, Decl(assignmentCompatWithObjectMembersOptionality.ts, 65, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality.ts, 2, 27)) + } + var d: D; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 68, 7)) +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 31)) + + var e: E; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 69, 7)) +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality.ts, 61, 5)) + + var f: F; +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 70, 7)) +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality.ts, 64, 5)) + + c = d; // error +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 53, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 68, 7)) + + c = e; // error +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 53, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 69, 7)) + + c = f; // ok +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 53, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 70, 7)) + + c = a; // ok +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 53, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 7)) + + a = d; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 68, 7)) + + a = e; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 69, 7)) + + a = f; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 70, 7)) + + a = c; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 53, 7)) + + b = d; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality.ts, 68, 7)) + + b = e; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality.ts, 69, 7)) + + b = f; // ok +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality.ts, 70, 7)) + + b = a; // ok +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality.ts, 55, 7)) + + b = c; // ok +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality.ts, 56, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality.ts, 53, 7)) +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.types b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.types new file mode 100644 index 00000000000..8727b7567b6 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality.types @@ -0,0 +1,272 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality.ts === +// Derived member is not optional but base member is, should be ok + +class Base { foo: string; } +>Base : Base +>foo : string + +class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +class Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +module TargetHasOptional { +>TargetHasOptional : typeof TargetHasOptional + + // targets + interface C { +>C : C + + opt?: Base +>opt : Base +>Base : Base + } + var c: C; +>c : C +>C : C + + var a: { opt?: Base; } +>a : { opt?: Base; } +>opt : Base +>Base : Base + + var b: typeof a = { opt: new Base() } +>b : { opt?: Base; } +>a : { opt?: Base; } +>{ opt: new Base() } : { opt: Base; } +>opt : Base +>new Base() : Base +>Base : typeof Base + + // sources + interface D { +>D : D + + opt: Base; +>opt : Base +>Base : Base + } + interface E { +>E : E + + opt: Derived; +>opt : Derived +>Derived : Derived + } + interface F { +>F : F + + opt?: Derived; +>opt : Derived +>Derived : Derived + } + var d: D; +>d : D +>D : D + + var e: E; +>e : E +>E : E + + var f: F; +>f : F +>F : F + + // all ok + c = d; +>c = d : D +>c : C +>d : D + + c = e; +>c = e : E +>c : C +>e : E + + c = f; +>c = f : F +>c : C +>f : F + + c = a; +>c = a : { opt?: Base; } +>c : C +>a : { opt?: Base; } + + a = d; +>a = d : D +>a : { opt?: Base; } +>d : D + + a = e; +>a = e : E +>a : { opt?: Base; } +>e : E + + a = f; +>a = f : F +>a : { opt?: Base; } +>f : F + + a = c; +>a = c : C +>a : { opt?: Base; } +>c : C + + b = d; +>b = d : D +>b : { opt?: Base; } +>d : D + + b = e; +>b = e : E +>b : { opt?: Base; } +>e : E + + b = f; +>b = f : F +>b : { opt?: Base; } +>f : F + + b = a; +>b = a : { opt?: Base; } +>b : { opt?: Base; } +>a : { opt?: Base; } + + b = c; +>b = c : C +>b : { opt?: Base; } +>c : C +} + +module SourceHasOptional { +>SourceHasOptional : typeof SourceHasOptional + + // targets + interface C { +>C : C + + opt: Base +>opt : Base +>Base : Base + } + var c: C; +>c : C +>C : C + + var a: { opt: Base; } +>a : { opt: Base; } +>opt : Base +>Base : Base + + var b = { opt: new Base() } +>b : { opt: Base; } +>{ opt: new Base() } : { opt: Base; } +>opt : Base +>new Base() : Base +>Base : typeof Base + + // sources + interface D { +>D : D + + opt?: Base; +>opt : Base +>Base : Base + } + interface E { +>E : E + + opt?: Derived; +>opt : Derived +>Derived : Derived + } + interface F { +>F : F + + opt: Derived; +>opt : Derived +>Derived : Derived + } + var d: D; +>d : D +>D : D + + var e: E; +>e : E +>E : E + + var f: F; +>f : F +>F : F + + c = d; // error +>c = d : D +>c : C +>d : D + + c = e; // error +>c = e : E +>c : C +>e : E + + c = f; // ok +>c = f : F +>c : C +>f : F + + c = a; // ok +>c = a : { opt: Base; } +>c : C +>a : { opt: Base; } + + a = d; // error +>a = d : D +>a : { opt: Base; } +>d : D + + a = e; // error +>a = e : E +>a : { opt: Base; } +>e : E + + a = f; // ok +>a = f : F +>a : { opt: Base; } +>f : F + + a = c; // ok +>a = c : C +>a : { opt: Base; } +>c : C + + b = d; // error +>b = d : D +>b : { opt: Base; } +>d : D + + b = e; // error +>b = e : E +>b : { opt: Base; } +>e : E + + b = f; // ok +>b = f : F +>b : { opt: Base; } +>f : F + + b = a; // ok +>b = a : { opt: Base; } +>b : { opt: Base; } +>a : { opt: Base; } + + b = c; // ok +>b = c : C +>b : { opt: Base; } +>c : C +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.symbols new file mode 100644 index 00000000000..b303c168408 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.symbols @@ -0,0 +1,245 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts === +// 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; } +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 3, 12)) + +class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 3, 27)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 4, 28)) + +class Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 4, 43)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 3, 27)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 5, 32)) + +module TargetHasOptional { +>TargetHasOptional : Symbol(TargetHasOptional, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 5, 47)) + + // targets + interface C { +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 7, 26)) + + opt?: Base +>opt : Symbol(C.opt, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 9, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + } + var c: C; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 12, 7)) +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 7, 26)) + + var a: { opt?: Base; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 12)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + + var b: typeof a = { opt: new Base() } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 23)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + + // sources + interface D { +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 41)) + + other: Base; +>other : Symbol(D.other, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 18, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + } + interface E { +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 20, 5)) + + other: Derived; +>other : Symbol(E.other, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 21, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 3, 27)) + } + interface F { +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 23, 5)) + + other?: Derived; +>other : Symbol(F.other, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 24, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 3, 27)) + } + var d: D; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 27, 7)) +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 41)) + + var e: E; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 28, 7)) +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 20, 5)) + + var f: F; +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 29, 7)) +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 23, 5)) + + // disallowed by weak type checking + c = d; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 12, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 27, 7)) + + c = e; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 12, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 28, 7)) + + c = f; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 12, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 29, 7)) + + a = d; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 27, 7)) + + a = e; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 28, 7)) + + a = f; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 29, 7)) + + b = d; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 27, 7)) + + b = e; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 28, 7)) + + b = f; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 29, 7)) + + // ok + c = a; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 12, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) + + a = c; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 12, 7)) + + b = a; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 14, 7)) + + b = c; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 15, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 12, 7)) +} + +module SourceHasOptional { +>SourceHasOptional : Symbol(SourceHasOptional, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 47, 1)) + + // targets + interface C { +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 49, 26)) + + opt: Base +>opt : Symbol(C.opt, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 51, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + } + var c: C; +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 54, 7)) +>C : Symbol(C, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 49, 26)) + + var a: { opt: Base; } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 12)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + + var b = { opt: new Base() } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 7)) +>opt : Symbol(opt, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 13)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + + // sources + interface D { +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 31)) + + other?: Base; +>other : Symbol(D.other, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 60, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 0, 0)) + } + interface E { +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 62, 5)) + + other?: Derived; +>other : Symbol(E.other, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 63, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 3, 27)) + } + interface F { +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 65, 5)) + + other: Derived; +>other : Symbol(F.other, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 66, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 3, 27)) + } + var d: D; +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 69, 7)) +>D : Symbol(D, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 31)) + + var e: E; +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 70, 7)) +>E : Symbol(E, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 62, 5)) + + var f: F; +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 71, 7)) +>F : Symbol(F, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 65, 5)) + + c = d; // error +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 54, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 69, 7)) + + c = e; // error +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 54, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 70, 7)) + + c = f; // error +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 54, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 71, 7)) + + c = a; // ok +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 54, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 7)) + + a = d; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 69, 7)) + + a = e; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 70, 7)) + + a = f; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 71, 7)) + + a = c; // ok +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 54, 7)) + + b = d; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 7)) +>d : Symbol(d, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 69, 7)) + + b = e; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 7)) +>e : Symbol(e, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 70, 7)) + + b = f; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 7)) +>f : Symbol(f, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 71, 7)) + + b = a; // ok +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 56, 7)) + + b = c; // ok +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 57, 7)) +>c : Symbol(c, Decl(assignmentCompatWithObjectMembersOptionality2.ts, 54, 7)) +} + diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.types b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.types new file mode 100644 index 00000000000..3481816b544 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.types @@ -0,0 +1,275 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts === +// 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; } +>Base : Base +>foo : string + +class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +class Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +module TargetHasOptional { +>TargetHasOptional : typeof TargetHasOptional + + // targets + interface C { +>C : C + + opt?: Base +>opt : Base +>Base : Base + } + var c: C; +>c : C +>C : C + + var a: { opt?: Base; } +>a : { opt?: Base; } +>opt : Base +>Base : Base + + var b: typeof a = { opt: new Base() } +>b : { opt?: Base; } +>a : { opt?: Base; } +>{ opt: new Base() } : { opt: Base; } +>opt : Base +>new Base() : Base +>Base : typeof Base + + // sources + interface D { +>D : D + + other: Base; +>other : Base +>Base : Base + } + interface E { +>E : E + + other: Derived; +>other : Derived +>Derived : Derived + } + interface F { +>F : F + + other?: Derived; +>other : Derived +>Derived : Derived + } + var d: D; +>d : D +>D : D + + var e: E; +>e : E +>E : E + + var f: F; +>f : F +>F : F + + // disallowed by weak type checking + c = d; +>c = d : D +>c : C +>d : D + + c = e; +>c = e : E +>c : C +>e : E + + c = f; +>c = f : F +>c : C +>f : F + + a = d; +>a = d : D +>a : { opt?: Base; } +>d : D + + a = e; +>a = e : E +>a : { opt?: Base; } +>e : E + + a = f; +>a = f : F +>a : { opt?: Base; } +>f : F + + b = d; +>b = d : D +>b : { opt?: Base; } +>d : D + + b = e; +>b = e : E +>b : { opt?: Base; } +>e : E + + b = f; +>b = f : F +>b : { opt?: Base; } +>f : F + + // ok + c = a; +>c = a : { opt?: Base; } +>c : C +>a : { opt?: Base; } + + a = c; +>a = c : C +>a : { opt?: Base; } +>c : C + + b = a; +>b = a : { opt?: Base; } +>b : { opt?: Base; } +>a : { opt?: Base; } + + b = c; +>b = c : C +>b : { opt?: Base; } +>c : C +} + +module SourceHasOptional { +>SourceHasOptional : typeof SourceHasOptional + + // targets + interface C { +>C : C + + opt: Base +>opt : Base +>Base : Base + } + var c: C; +>c : C +>C : C + + var a: { opt: Base; } +>a : { opt: Base; } +>opt : Base +>Base : Base + + var b = { opt: new Base() } +>b : { opt: Base; } +>{ opt: new Base() } : { opt: Base; } +>opt : Base +>new Base() : Base +>Base : typeof Base + + // sources + interface D { +>D : D + + other?: Base; +>other : Base +>Base : Base + } + interface E { +>E : E + + other?: Derived; +>other : Derived +>Derived : Derived + } + interface F { +>F : F + + other: Derived; +>other : Derived +>Derived : Derived + } + var d: D; +>d : D +>D : D + + var e: E; +>e : E +>E : E + + var f: F; +>f : F +>F : F + + c = d; // error +>c = d : D +>c : C +>d : D + + c = e; // error +>c = e : E +>c : C +>e : E + + c = f; // error +>c = f : F +>c : C +>f : F + + c = a; // ok +>c = a : { opt: Base; } +>c : C +>a : { opt: Base; } + + a = d; // error +>a = d : D +>a : { opt: Base; } +>d : D + + a = e; // error +>a = e : E +>a : { opt: Base; } +>e : E + + a = f; // error +>a = f : F +>a : { opt: Base; } +>f : F + + a = c; // ok +>a = c : C +>a : { opt: Base; } +>c : C + + b = d; // error +>b = d : D +>b : { opt: Base; } +>d : D + + b = e; // error +>b = e : E +>b : { opt: Base; } +>e : E + + b = f; // error +>b = f : F +>b : { opt: Base; } +>f : F + + b = a; // ok +>b = a : { opt: Base; } +>b : { opt: Base; } +>a : { opt: Base; } + + b = c; // ok +>b = c : C +>b : { opt: Base; } +>c : C +} + diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.symbols b/tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.symbols new file mode 100644 index 00000000000..b33dd82f99a --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.symbols @@ -0,0 +1,255 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersStringNumericNames.ts === +// 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 { +>JustStrings : Symbol(JustStrings, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 0, 0)) + + class S { '1': string; } +>S : Symbol(S, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 3, 20)) + + class T { '1.': string; } +>T : Symbol(T, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 4, 28)) + + var s: S; +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 6, 7)) +>S : Symbol(S, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 3, 20)) + + var t: T; +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 7, 7)) +>T : Symbol(T, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 4, 28)) + + interface S2 { '1': string; bar?: string } +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 7, 13)) +>bar : Symbol(S2.bar, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 9, 31)) + + interface T2 { '1.0': string; baz?: string } +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 9, 46)) +>baz : Symbol(T2.baz, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 10, 33)) + + var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 7, 13)) + + var t2: T2; +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 12, 7)) +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 9, 46)) + + var a: { '1.': string; bar?: string } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 14, 7)) +>bar : Symbol(bar, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 14, 26)) + + var b: { '1.0': string; baz?: string } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 15, 7)) +>baz : Symbol(baz, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 15, 27)) + + var a2 = { '1.0': '' }; +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) + + var b2 = { '1': '' }; +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 18, 7)) + + s = t; +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 6, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 7, 7)) + + t = s; +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 7, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 6, 7)) + + s = s2; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 6, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) + + s = a2; +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 6, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) + + s2 = t2; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 12, 7)) + + t2 = s2; +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 12, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) + + s2 = t; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 7, 7)) + + s2 = b; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 15, 7)) + + s2 = a2; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) + + a = b; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 14, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 15, 7)) + + b = a; +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 15, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 14, 7)) + + a = s; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 14, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 6, 7)) + + a = s2; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 14, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 11, 7)) + + a = a2; +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 14, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) + + a2 = b2; +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 18, 7)) + + b2 = a2; +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 18, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) + + a2 = b; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 15, 7)) + + a2 = t2; // ok +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 12, 7)) + + a2 = t; +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 17, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 7, 7)) +} + +module NumbersAndStrings { +>NumbersAndStrings : Symbol(NumbersAndStrings, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 42, 1)) + + class S { '1': string; } +>S : Symbol(S, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 44, 26)) + + class T { 1: string; } +>T : Symbol(T, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 45, 28)) + + var s: S; +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 47, 7)) +>S : Symbol(S, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 44, 26)) + + var t: T; +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 48, 7)) +>T : Symbol(T, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 45, 28)) + + interface S2 { '1': string; bar?: string } +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 48, 13)) +>bar : Symbol(S2.bar, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 50, 31)) + + interface T2 { 1.0: string; baz?: string } +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 50, 46)) +>baz : Symbol(T2.baz, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 51, 31)) + + var s2: S2; +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) +>S2 : Symbol(S2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 48, 13)) + + var t2: T2; +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 53, 7)) +>T2 : Symbol(T2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 50, 46)) + + var a: { '1.': string; bar?: string } +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 7)) +>bar : Symbol(bar, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 26)) + + var b: { 1.0: string; baz?: string } +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 56, 7)) +>baz : Symbol(baz, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 56, 25)) + + var a2 = { '1.0': '' }; +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) + + var b2 = { 1.: '' }; +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 59, 7)) + + s = t; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 47, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 48, 7)) + + t = s; // ok +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 48, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 47, 7)) + + s = s2; // ok +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 47, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) + + s = a2; // error +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 47, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) + + s2 = t2; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 53, 7)) + + t2 = s2; // ok +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 53, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) + + s2 = t; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 48, 7)) + + s2 = b; // ok +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 56, 7)) + + s2 = a2; // error +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) + + a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 56, 7)) + + b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 56, 7)) +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 7)) + + a = s; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 7)) +>s : Symbol(s, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 47, 7)) + + a = s2; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 7)) +>s2 : Symbol(s2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 52, 7)) + + a = a2; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) + + a = b2; // error +>a : Symbol(a, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 55, 7)) +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 59, 7)) + + a2 = b2; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 59, 7)) + + b2 = a2; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 59, 7)) +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) + + a2 = b; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) +>b : Symbol(b, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 56, 7)) + + a2 = t2; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) +>t2 : Symbol(t2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 53, 7)) + + a2 = t; // error +>a2 : Symbol(a2, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 58, 7)) +>t : Symbol(t, Decl(assignmentCompatWithObjectMembersStringNumericNames.ts, 48, 7)) +} diff --git a/tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.types b/tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.types new file mode 100644 index 00000000000..6d021b024cb --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithObjectMembersStringNumericNames.types @@ -0,0 +1,302 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersStringNumericNames.ts === +// 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 { +>JustStrings : typeof JustStrings + + class S { '1': string; } +>S : S + + class T { '1.': string; } +>T : T + + var s: S; +>s : S +>S : S + + var t: T; +>t : T +>T : T + + interface S2 { '1': string; bar?: string } +>S2 : S2 +>bar : string + + interface T2 { '1.0': string; baz?: string } +>T2 : T2 +>baz : string + + var s2: S2; +>s2 : S2 +>S2 : S2 + + var t2: T2; +>t2 : T2 +>T2 : T2 + + var a: { '1.': string; bar?: string } +>a : { '1.': string; bar?: string; } +>bar : string + + var b: { '1.0': string; baz?: string } +>b : { '1.0': string; baz?: string; } +>baz : string + + var a2 = { '1.0': '' }; +>a2 : { '1.0': string; } +>{ '1.0': '' } : { '1.0': string; } +>'' : "" + + var b2 = { '1': '' }; +>b2 : { '1': string; } +>{ '1': '' } : { '1': string; } +>'' : "" + + s = t; +>s = t : T +>s : S +>t : T + + t = s; +>t = s : S +>t : T +>s : S + + s = s2; // ok +>s = s2 : S2 +>s : S +>s2 : S2 + + s = a2; +>s = a2 : { '1.0': string; } +>s : S +>a2 : { '1.0': string; } + + s2 = t2; +>s2 = t2 : T2 +>s2 : S2 +>t2 : T2 + + t2 = s2; +>t2 = s2 : S2 +>t2 : T2 +>s2 : S2 + + s2 = t; +>s2 = t : T +>s2 : S2 +>t : T + + s2 = b; +>s2 = b : { '1.0': string; baz?: string; } +>s2 : S2 +>b : { '1.0': string; baz?: string; } + + s2 = a2; +>s2 = a2 : { '1.0': string; } +>s2 : S2 +>a2 : { '1.0': string; } + + a = b; +>a = b : { '1.0': string; baz?: string; } +>a : { '1.': string; bar?: string; } +>b : { '1.0': string; baz?: string; } + + b = a; +>b = a : { '1.': string; bar?: string; } +>b : { '1.0': string; baz?: string; } +>a : { '1.': string; bar?: string; } + + a = s; +>a = s : S +>a : { '1.': string; bar?: string; } +>s : S + + a = s2; +>a = s2 : S2 +>a : { '1.': string; bar?: string; } +>s2 : S2 + + a = a2; +>a = a2 : { '1.0': string; } +>a : { '1.': string; bar?: string; } +>a2 : { '1.0': string; } + + a2 = b2; +>a2 = b2 : { '1': string; } +>a2 : { '1.0': string; } +>b2 : { '1': string; } + + b2 = a2; +>b2 = a2 : { '1.0': string; } +>b2 : { '1': string; } +>a2 : { '1.0': string; } + + a2 = b; // ok +>a2 = b : { '1.0': string; baz?: string; } +>a2 : { '1.0': string; } +>b : { '1.0': string; baz?: string; } + + a2 = t2; // ok +>a2 = t2 : T2 +>a2 : { '1.0': string; } +>t2 : T2 + + a2 = t; +>a2 = t : T +>a2 : { '1.0': string; } +>t : T +} + +module NumbersAndStrings { +>NumbersAndStrings : typeof NumbersAndStrings + + class S { '1': string; } +>S : S + + class T { 1: string; } +>T : T + + var s: S; +>s : S +>S : S + + var t: T; +>t : T +>T : T + + interface S2 { '1': string; bar?: string } +>S2 : S2 +>bar : string + + interface T2 { 1.0: string; baz?: string } +>T2 : T2 +>baz : string + + var s2: S2; +>s2 : S2 +>S2 : S2 + + var t2: T2; +>t2 : T2 +>T2 : T2 + + var a: { '1.': string; bar?: string } +>a : { '1.': string; bar?: string; } +>bar : string + + var b: { 1.0: string; baz?: string } +>b : { 1.0: string; baz?: string; } +>baz : string + + var a2 = { '1.0': '' }; +>a2 : { '1.0': string; } +>{ '1.0': '' } : { '1.0': string; } +>'' : "" + + var b2 = { 1.: '' }; +>b2 : { 1.: string; } +>{ 1.: '' } : { 1.: string; } +>'' : "" + + s = t; // ok +>s = t : T +>s : S +>t : T + + t = s; // ok +>t = s : S +>t : T +>s : S + + s = s2; // ok +>s = s2 : S2 +>s : S +>s2 : S2 + + s = a2; // error +>s = a2 : { '1.0': string; } +>s : S +>a2 : { '1.0': string; } + + s2 = t2; // ok +>s2 = t2 : T2 +>s2 : S2 +>t2 : T2 + + t2 = s2; // ok +>t2 = s2 : S2 +>t2 : T2 +>s2 : S2 + + s2 = t; // ok +>s2 = t : T +>s2 : S2 +>t : T + + s2 = b; // ok +>s2 = b : { 1.0: string; baz?: string; } +>s2 : S2 +>b : { 1.0: string; baz?: string; } + + s2 = a2; // error +>s2 = a2 : { '1.0': string; } +>s2 : S2 +>a2 : { '1.0': string; } + + a = b; // error +>a = b : { 1.0: string; baz?: string; } +>a : { '1.': string; bar?: string; } +>b : { 1.0: string; baz?: string; } + + b = a; // error +>b = a : { '1.': string; bar?: string; } +>b : { 1.0: string; baz?: string; } +>a : { '1.': string; bar?: string; } + + a = s; // error +>a = s : S +>a : { '1.': string; bar?: string; } +>s : S + + a = s2; // error +>a = s2 : S2 +>a : { '1.': string; bar?: string; } +>s2 : S2 + + a = a2; // error +>a = a2 : { '1.0': string; } +>a : { '1.': string; bar?: string; } +>a2 : { '1.0': string; } + + a = b2; // error +>a = b2 : { 1.: string; } +>a : { '1.': string; bar?: string; } +>b2 : { 1.: string; } + + a2 = b2; // error +>a2 = b2 : { 1.: string; } +>a2 : { '1.0': string; } +>b2 : { 1.: string; } + + b2 = a2; // error +>b2 = a2 : { '1.0': string; } +>b2 : { 1.: string; } +>a2 : { '1.0': string; } + + a2 = b; // error +>a2 = b : { 1.0: string; baz?: string; } +>a2 : { '1.0': string; } +>b : { 1.0: string; baz?: string; } + + a2 = t2; // error +>a2 = t2 : T2 +>a2 : { '1.0': string; } +>t2 : T2 + + a2 = t; // error +>a2 = t : T +>a2 : { '1.0': string; } +>t : T +} diff --git a/tests/baselines/reference/assignmentCompatWithOverloads.symbols b/tests/baselines/reference/assignmentCompatWithOverloads.symbols new file mode 100644 index 00000000000..34e108e6647 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithOverloads.symbols @@ -0,0 +1,64 @@ +=== tests/cases/compiler/assignmentCompatWithOverloads.ts === +function f1(x: string): number { return null; } +>f1 : Symbol(f1, Decl(assignmentCompatWithOverloads.ts, 0, 0)) +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 0, 12)) + +function f2(x: string): string { return null; } +>f2 : Symbol(f2, Decl(assignmentCompatWithOverloads.ts, 0, 47)) +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 2, 12)) + +function f3(x: number): number { return null; } +>f3 : Symbol(f3, Decl(assignmentCompatWithOverloads.ts, 2, 47)) +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 4, 12)) + +function f4(x: string): string; +>f4 : Symbol(f4, Decl(assignmentCompatWithOverloads.ts, 4, 47), Decl(assignmentCompatWithOverloads.ts, 6, 31), Decl(assignmentCompatWithOverloads.ts, 8, 31)) +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 6, 12)) + +function f4(x: number): number; +>f4 : Symbol(f4, Decl(assignmentCompatWithOverloads.ts, 4, 47), Decl(assignmentCompatWithOverloads.ts, 6, 31), Decl(assignmentCompatWithOverloads.ts, 8, 31)) +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 8, 12)) + +function f4(x: any): any { return undefined; } +>f4 : Symbol(f4, Decl(assignmentCompatWithOverloads.ts, 4, 47), Decl(assignmentCompatWithOverloads.ts, 6, 31), Decl(assignmentCompatWithOverloads.ts, 8, 31)) +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 10, 12)) +>undefined : Symbol(undefined) + +var g: (s1: string) => number; +>g : Symbol(g, Decl(assignmentCompatWithOverloads.ts, 12, 3)) +>s1 : Symbol(s1, Decl(assignmentCompatWithOverloads.ts, 12, 8)) + +g = f1; // OK +>g : Symbol(g, Decl(assignmentCompatWithOverloads.ts, 12, 3)) +>f1 : Symbol(f1, Decl(assignmentCompatWithOverloads.ts, 0, 0)) + +g = f2; // Error +>g : Symbol(g, Decl(assignmentCompatWithOverloads.ts, 12, 3)) +>f2 : Symbol(f2, Decl(assignmentCompatWithOverloads.ts, 0, 47)) + +g = f3; // Error +>g : Symbol(g, Decl(assignmentCompatWithOverloads.ts, 12, 3)) +>f3 : Symbol(f3, Decl(assignmentCompatWithOverloads.ts, 2, 47)) + +g = f4; // Error +>g : Symbol(g, Decl(assignmentCompatWithOverloads.ts, 12, 3)) +>f4 : Symbol(f4, Decl(assignmentCompatWithOverloads.ts, 4, 47), Decl(assignmentCompatWithOverloads.ts, 6, 31), Decl(assignmentCompatWithOverloads.ts, 8, 31)) + +class C { +>C : Symbol(C, Decl(assignmentCompatWithOverloads.ts, 20, 7)) + + constructor(x: string); +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 23, 16)) + +constructor(x: any) {} +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 24, 12)) +} + +var d: new(x: number) => void; +>d : Symbol(d, Decl(assignmentCompatWithOverloads.ts, 27, 3)) +>x : Symbol(x, Decl(assignmentCompatWithOverloads.ts, 27, 11)) + +d = C; // Error +>d : Symbol(d, Decl(assignmentCompatWithOverloads.ts, 27, 3)) +>C : Symbol(C, Decl(assignmentCompatWithOverloads.ts, 20, 7)) + diff --git a/tests/baselines/reference/assignmentCompatWithOverloads.types b/tests/baselines/reference/assignmentCompatWithOverloads.types new file mode 100644 index 00000000000..5da16dc01b2 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithOverloads.types @@ -0,0 +1,72 @@ +=== tests/cases/compiler/assignmentCompatWithOverloads.ts === +function f1(x: string): number { return null; } +>f1 : (x: string) => number +>x : string +>null : null + +function f2(x: string): string { return null; } +>f2 : (x: string) => string +>x : string +>null : null + +function f3(x: number): number { return null; } +>f3 : (x: number) => number +>x : number +>null : null + +function f4(x: string): string; +>f4 : { (x: string): string; (x: number): number; } +>x : string + +function f4(x: number): number; +>f4 : { (x: string): string; (x: number): number; } +>x : number + +function f4(x: any): any { return undefined; } +>f4 : { (x: string): string; (x: number): number; } +>x : any +>undefined : undefined + +var g: (s1: string) => number; +>g : (s1: string) => number +>s1 : string + +g = f1; // OK +>g = f1 : (x: string) => number +>g : (s1: string) => number +>f1 : (x: string) => number + +g = f2; // Error +>g = f2 : (x: string) => string +>g : (s1: string) => number +>f2 : (x: string) => string + +g = f3; // Error +>g = f3 : (x: number) => number +>g : (s1: string) => number +>f3 : (x: number) => number + +g = f4; // Error +>g = f4 : { (x: string): string; (x: number): number; } +>g : (s1: string) => number +>f4 : { (x: string): string; (x: number): number; } + +class C { +>C : C + + constructor(x: string); +>x : string + +constructor(x: any) {} +>x : any +} + +var d: new(x: number) => void; +>d : new (x: number) => void +>x : number + +d = C; // Error +>d = C : typeof C +>d : new (x: number) => void +>C : typeof C + diff --git a/tests/baselines/reference/assignmentCompatWithStringIndexer.symbols b/tests/baselines/reference/assignmentCompatWithStringIndexer.symbols new file mode 100644 index 00000000000..6649a8bb0d9 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithStringIndexer.symbols @@ -0,0 +1,156 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithStringIndexer.ts === +// index signatures must be compatible in assignments + +interface Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithStringIndexer.ts, 2, 16)) + +interface Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer.ts, 2, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithStringIndexer.ts, 3, 32)) + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer.ts, 3, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer.ts, 2, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithStringIndexer.ts, 4, 36)) + +class A { +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer.ts, 4, 51)) + + [x: string]: Base; +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 7, 5)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) +} + +var a: A; +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer.ts, 10, 3)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer.ts, 4, 51)) + +var b: { [x: string]: Derived; } +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer.ts, 12, 3)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 12, 10)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer.ts, 2, 31)) + +a = b; // ok +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer.ts, 10, 3)) +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer.ts, 12, 3)) + +b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer.ts, 12, 3)) +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer.ts, 10, 3)) + +var b2: { [x: string]: Derived2; } +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer.ts, 16, 3)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 16, 11)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer.ts, 3, 47)) + +a = b2; // ok +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer.ts, 10, 3)) +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer.ts, 16, 3)) + +b2 = a; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer.ts, 16, 3)) +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer.ts, 10, 3)) + +module Generics { +>Generics : Symbol(Generics, Decl(assignmentCompatWithStringIndexer.ts, 18, 7)) + + class A { +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer.ts, 20, 17)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer.ts, 21, 12)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) + + [x: string]: T; +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 22, 9)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer.ts, 21, 12)) + } + + class B extends A { +>B : Symbol(B, Decl(assignmentCompatWithStringIndexer.ts, 23, 5)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer.ts, 20, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) + + [x: string]: Derived; // ok +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 26, 9)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer.ts, 2, 31)) + } + + var b1: { [x: string]: Derived; }; +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer.ts, 29, 7)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 29, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer.ts, 2, 31)) + + var a1: A; +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer.ts, 30, 7)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer.ts, 20, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) + + a1 = b1; // ok +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer.ts, 30, 7)) +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer.ts, 29, 7)) + + b1 = a1; // error +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer.ts, 29, 7)) +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer.ts, 30, 7)) + + class B2 extends A { +>B2 : Symbol(B2, Decl(assignmentCompatWithStringIndexer.ts, 32, 12)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer.ts, 20, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) + + [x: string]: Derived2; // ok +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 35, 9)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer.ts, 3, 47)) + } + + var b2: { [x: string]: Derived2; }; +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer.ts, 38, 7)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 38, 15)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer.ts, 3, 47)) + + a1 = b2; // ok +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer.ts, 30, 7)) +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer.ts, 38, 7)) + + b2 = a1; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer.ts, 38, 7)) +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer.ts, 30, 7)) + + function foo() { +>foo : Symbol(foo, Decl(assignmentCompatWithStringIndexer.ts, 40, 12)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer.ts, 42, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer.ts, 0, 0)) + + var b3: { [x: string]: Derived; }; +>b3 : Symbol(b3, Decl(assignmentCompatWithStringIndexer.ts, 43, 11)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 43, 19)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer.ts, 2, 31)) + + var a3: A; +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer.ts, 44, 11)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer.ts, 20, 17)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer.ts, 42, 17)) + + a3 = b3; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer.ts, 44, 11)) +>b3 : Symbol(b3, Decl(assignmentCompatWithStringIndexer.ts, 43, 11)) + + b3 = a3; // error +>b3 : Symbol(b3, Decl(assignmentCompatWithStringIndexer.ts, 43, 11)) +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer.ts, 44, 11)) + + var b4: { [x: string]: Derived2; }; +>b4 : Symbol(b4, Decl(assignmentCompatWithStringIndexer.ts, 48, 11)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer.ts, 48, 19)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer.ts, 3, 47)) + + a3 = b4; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer.ts, 44, 11)) +>b4 : Symbol(b4, Decl(assignmentCompatWithStringIndexer.ts, 48, 11)) + + b4 = a3; // error +>b4 : Symbol(b4, Decl(assignmentCompatWithStringIndexer.ts, 48, 11)) +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer.ts, 44, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithStringIndexer.types b/tests/baselines/reference/assignmentCompatWithStringIndexer.types new file mode 100644 index 00000000000..2ecb1889406 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithStringIndexer.types @@ -0,0 +1,168 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithStringIndexer.ts === +// index signatures must be compatible in assignments + +interface Base { foo: string; } +>Base : Base +>foo : string + +interface Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +class A { +>A : A + + [x: string]: Base; +>x : string +>Base : Base +} + +var a: A; +>a : A +>A : A + +var b: { [x: string]: Derived; } +>b : { [x: string]: Derived; } +>x : string +>Derived : Derived + +a = b; // ok +>a = b : { [x: string]: Derived; } +>a : A +>b : { [x: string]: Derived; } + +b = a; // error +>b = a : A +>b : { [x: string]: Derived; } +>a : A + +var b2: { [x: string]: Derived2; } +>b2 : { [x: string]: Derived2; } +>x : string +>Derived2 : Derived2 + +a = b2; // ok +>a = b2 : { [x: string]: Derived2; } +>a : A +>b2 : { [x: string]: Derived2; } + +b2 = a; // error +>b2 = a : A +>b2 : { [x: string]: Derived2; } +>a : A + +module Generics { +>Generics : typeof Generics + + class A { +>A : A +>T : T +>Base : Base + + [x: string]: T; +>x : string +>T : T + } + + class B extends A { +>B : B +>A : A +>Base : Base + + [x: string]: Derived; // ok +>x : string +>Derived : Derived + } + + var b1: { [x: string]: Derived; }; +>b1 : { [x: string]: Derived; } +>x : string +>Derived : Derived + + var a1: A; +>a1 : A +>A : A +>Base : Base + + a1 = b1; // ok +>a1 = b1 : { [x: string]: Derived; } +>a1 : A +>b1 : { [x: string]: Derived; } + + b1 = a1; // error +>b1 = a1 : A +>b1 : { [x: string]: Derived; } +>a1 : A + + class B2 extends A { +>B2 : B2 +>A : A +>Base : Base + + [x: string]: Derived2; // ok +>x : string +>Derived2 : Derived2 + } + + var b2: { [x: string]: Derived2; }; +>b2 : { [x: string]: Derived2; } +>x : string +>Derived2 : Derived2 + + a1 = b2; // ok +>a1 = b2 : { [x: string]: Derived2; } +>a1 : A +>b2 : { [x: string]: Derived2; } + + b2 = a1; // error +>b2 = a1 : A +>b2 : { [x: string]: Derived2; } +>a1 : A + + function foo() { +>foo : () => void +>T : T +>Base : Base + + var b3: { [x: string]: Derived; }; +>b3 : { [x: string]: Derived; } +>x : string +>Derived : Derived + + var a3: A; +>a3 : A +>A : A +>T : T + + a3 = b3; // error +>a3 = b3 : { [x: string]: Derived; } +>a3 : A +>b3 : { [x: string]: Derived; } + + b3 = a3; // error +>b3 = a3 : A +>b3 : { [x: string]: Derived; } +>a3 : A + + var b4: { [x: string]: Derived2; }; +>b4 : { [x: string]: Derived2; } +>x : string +>Derived2 : Derived2 + + a3 = b4; // error +>a3 = b4 : { [x: string]: Derived2; } +>a3 : A +>b4 : { [x: string]: Derived2; } + + b4 = a3; // error +>b4 = a3 : A +>b4 : { [x: string]: Derived2; } +>a3 : A + } +} diff --git a/tests/baselines/reference/assignmentCompatWithStringIndexer2.symbols b/tests/baselines/reference/assignmentCompatWithStringIndexer2.symbols new file mode 100644 index 00000000000..b1ce13bdbb7 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithStringIndexer2.symbols @@ -0,0 +1,156 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithStringIndexer2.ts === +// index signatures must be compatible in assignments + +interface Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithStringIndexer2.ts, 2, 16)) + +interface Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer2.ts, 2, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithStringIndexer2.ts, 3, 32)) + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer2.ts, 3, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer2.ts, 2, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithStringIndexer2.ts, 4, 36)) + +interface A { +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer2.ts, 4, 51)) + + [x: string]: Base; +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 7, 5)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) +} + +var a: A; +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer2.ts, 10, 3)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer2.ts, 4, 51)) + +var b: { [x: string]: Derived; } +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer2.ts, 12, 3)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 12, 10)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer2.ts, 2, 31)) + +a = b; // ok +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer2.ts, 10, 3)) +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer2.ts, 12, 3)) + +b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer2.ts, 12, 3)) +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer2.ts, 10, 3)) + +var b2: { [x: string]: Derived2; } +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer2.ts, 16, 3)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 16, 11)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer2.ts, 3, 47)) + +a = b2; // ok +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer2.ts, 10, 3)) +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer2.ts, 16, 3)) + +b2 = a; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer2.ts, 16, 3)) +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer2.ts, 10, 3)) + +module Generics { +>Generics : Symbol(Generics, Decl(assignmentCompatWithStringIndexer2.ts, 18, 7)) + + interface A { +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer2.ts, 20, 17)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer2.ts, 21, 16)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) + + [x: string]: T; +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 22, 9)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer2.ts, 21, 16)) + } + + interface B extends A { +>B : Symbol(B, Decl(assignmentCompatWithStringIndexer2.ts, 23, 5)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer2.ts, 20, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) + + [x: string]: Derived; // ok +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 26, 9)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer2.ts, 2, 31)) + } + + var b1: { [x: string]: Derived; }; +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer2.ts, 29, 7)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 29, 15)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer2.ts, 2, 31)) + + var a1: A; +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer2.ts, 30, 7)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer2.ts, 20, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) + + a1 = b1; // ok +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer2.ts, 30, 7)) +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer2.ts, 29, 7)) + + b1 = a1; // error +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer2.ts, 29, 7)) +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer2.ts, 30, 7)) + + interface B2 extends A { +>B2 : Symbol(B2, Decl(assignmentCompatWithStringIndexer2.ts, 32, 12)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer2.ts, 20, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) + + [x: string]: Derived2; // ok +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 35, 9)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer2.ts, 3, 47)) + } + + var b2: { [x: string]: Derived2; }; +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer2.ts, 38, 7)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 38, 15)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer2.ts, 3, 47)) + + a1 = b2; // ok +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer2.ts, 30, 7)) +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer2.ts, 38, 7)) + + b2 = a1; // error +>b2 : Symbol(b2, Decl(assignmentCompatWithStringIndexer2.ts, 38, 7)) +>a1 : Symbol(a1, Decl(assignmentCompatWithStringIndexer2.ts, 30, 7)) + + function foo() { +>foo : Symbol(foo, Decl(assignmentCompatWithStringIndexer2.ts, 40, 12)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer2.ts, 42, 17)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer2.ts, 0, 0)) + + var b3: { [x: string]: Derived; }; +>b3 : Symbol(b3, Decl(assignmentCompatWithStringIndexer2.ts, 43, 11)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 43, 19)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer2.ts, 2, 31)) + + var a3: A; +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer2.ts, 44, 11)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer2.ts, 20, 17)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer2.ts, 42, 17)) + + a3 = b3; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer2.ts, 44, 11)) +>b3 : Symbol(b3, Decl(assignmentCompatWithStringIndexer2.ts, 43, 11)) + + b3 = a3; // error +>b3 : Symbol(b3, Decl(assignmentCompatWithStringIndexer2.ts, 43, 11)) +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer2.ts, 44, 11)) + + var b4: { [x: string]: Derived2; }; +>b4 : Symbol(b4, Decl(assignmentCompatWithStringIndexer2.ts, 48, 11)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer2.ts, 48, 19)) +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer2.ts, 3, 47)) + + a3 = b4; // error +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer2.ts, 44, 11)) +>b4 : Symbol(b4, Decl(assignmentCompatWithStringIndexer2.ts, 48, 11)) + + b4 = a3; // error +>b4 : Symbol(b4, Decl(assignmentCompatWithStringIndexer2.ts, 48, 11)) +>a3 : Symbol(a3, Decl(assignmentCompatWithStringIndexer2.ts, 44, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithStringIndexer2.types b/tests/baselines/reference/assignmentCompatWithStringIndexer2.types new file mode 100644 index 00000000000..4c9d2729a6c --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithStringIndexer2.types @@ -0,0 +1,168 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithStringIndexer2.ts === +// index signatures must be compatible in assignments + +interface Base { foo: string; } +>Base : Base +>foo : string + +interface Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +interface A { +>A : A + + [x: string]: Base; +>x : string +>Base : Base +} + +var a: A; +>a : A +>A : A + +var b: { [x: string]: Derived; } +>b : { [x: string]: Derived; } +>x : string +>Derived : Derived + +a = b; // ok +>a = b : { [x: string]: Derived; } +>a : A +>b : { [x: string]: Derived; } + +b = a; // error +>b = a : A +>b : { [x: string]: Derived; } +>a : A + +var b2: { [x: string]: Derived2; } +>b2 : { [x: string]: Derived2; } +>x : string +>Derived2 : Derived2 + +a = b2; // ok +>a = b2 : { [x: string]: Derived2; } +>a : A +>b2 : { [x: string]: Derived2; } + +b2 = a; // error +>b2 = a : A +>b2 : { [x: string]: Derived2; } +>a : A + +module Generics { +>Generics : typeof Generics + + interface A { +>A : A +>T : T +>Base : Base + + [x: string]: T; +>x : string +>T : T + } + + interface B extends A { +>B : B +>A : A +>Base : Base + + [x: string]: Derived; // ok +>x : string +>Derived : Derived + } + + var b1: { [x: string]: Derived; }; +>b1 : { [x: string]: Derived; } +>x : string +>Derived : Derived + + var a1: A; +>a1 : A +>A : A +>Base : Base + + a1 = b1; // ok +>a1 = b1 : { [x: string]: Derived; } +>a1 : A +>b1 : { [x: string]: Derived; } + + b1 = a1; // error +>b1 = a1 : A +>b1 : { [x: string]: Derived; } +>a1 : A + + interface B2 extends A { +>B2 : B2 +>A : A +>Base : Base + + [x: string]: Derived2; // ok +>x : string +>Derived2 : Derived2 + } + + var b2: { [x: string]: Derived2; }; +>b2 : { [x: string]: Derived2; } +>x : string +>Derived2 : Derived2 + + a1 = b2; // ok +>a1 = b2 : { [x: string]: Derived2; } +>a1 : A +>b2 : { [x: string]: Derived2; } + + b2 = a1; // error +>b2 = a1 : A +>b2 : { [x: string]: Derived2; } +>a1 : A + + function foo() { +>foo : () => void +>T : T +>Base : Base + + var b3: { [x: string]: Derived; }; +>b3 : { [x: string]: Derived; } +>x : string +>Derived : Derived + + var a3: A; +>a3 : A +>A : A +>T : T + + a3 = b3; // error +>a3 = b3 : { [x: string]: Derived; } +>a3 : A +>b3 : { [x: string]: Derived; } + + b3 = a3; // error +>b3 = a3 : A +>b3 : { [x: string]: Derived; } +>a3 : A + + var b4: { [x: string]: Derived2; }; +>b4 : { [x: string]: Derived2; } +>x : string +>Derived2 : Derived2 + + a3 = b4; // error +>a3 = b4 : { [x: string]: Derived2; } +>a3 : A +>b4 : { [x: string]: Derived2; } + + b4 = a3; // error +>b4 = a3 : A +>b4 : { [x: string]: Derived2; } +>a3 : A + } +} diff --git a/tests/baselines/reference/assignmentCompatWithStringIndexer3.symbols b/tests/baselines/reference/assignmentCompatWithStringIndexer3.symbols new file mode 100644 index 00000000000..751fb44c8dc --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithStringIndexer3.symbols @@ -0,0 +1,68 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithStringIndexer3.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer3.ts, 0, 0)) +>foo : Symbol(Base.foo, Decl(assignmentCompatWithStringIndexer3.ts, 2, 16)) + +interface Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer3.ts, 2, 31)) +>Base : Symbol(Base, Decl(assignmentCompatWithStringIndexer3.ts, 0, 0)) +>bar : Symbol(Derived.bar, Decl(assignmentCompatWithStringIndexer3.ts, 3, 32)) + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(assignmentCompatWithStringIndexer3.ts, 3, 47)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer3.ts, 2, 31)) +>baz : Symbol(Derived2.baz, Decl(assignmentCompatWithStringIndexer3.ts, 4, 36)) + +var a: A; +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer3.ts, 6, 3)) + +var b1: { [x: string]: string; } +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer3.ts, 7, 3)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer3.ts, 7, 11)) + +a = b1; // error +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer3.ts, 6, 3)) +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer3.ts, 7, 3)) + +b1 = a; // error +>b1 : Symbol(b1, Decl(assignmentCompatWithStringIndexer3.ts, 7, 3)) +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer3.ts, 6, 3)) + +module Generics { +>Generics : Symbol(Generics, Decl(assignmentCompatWithStringIndexer3.ts, 9, 7)) + + class A { +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer3.ts, 11, 17)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer3.ts, 12, 12)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer3.ts, 2, 31)) + + [x: string]: T; +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer3.ts, 13, 9)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer3.ts, 12, 12)) + } + + function foo() { +>foo : Symbol(foo, Decl(assignmentCompatWithStringIndexer3.ts, 14, 5)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer3.ts, 16, 17)) +>Derived : Symbol(Derived, Decl(assignmentCompatWithStringIndexer3.ts, 2, 31)) + + var a: A; +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer3.ts, 17, 11)) +>A : Symbol(A, Decl(assignmentCompatWithStringIndexer3.ts, 11, 17)) +>T : Symbol(T, Decl(assignmentCompatWithStringIndexer3.ts, 16, 17)) + + var b: { [x: string]: string; } +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer3.ts, 18, 11)) +>x : Symbol(x, Decl(assignmentCompatWithStringIndexer3.ts, 18, 18)) + + a = b; // error +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer3.ts, 17, 11)) +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer3.ts, 18, 11)) + + b = a; // error +>b : Symbol(b, Decl(assignmentCompatWithStringIndexer3.ts, 18, 11)) +>a : Symbol(a, Decl(assignmentCompatWithStringIndexer3.ts, 17, 11)) + } +} diff --git a/tests/baselines/reference/assignmentCompatWithStringIndexer3.types b/tests/baselines/reference/assignmentCompatWithStringIndexer3.types new file mode 100644 index 00000000000..eda67798465 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatWithStringIndexer3.types @@ -0,0 +1,73 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithStringIndexer3.ts === +// Derived type indexer must be subtype of base type indexer + +interface Base { foo: string; } +>Base : Base +>foo : string + +interface Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + +interface Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + +var a: A; +>a : any +>A : No type information available! + +var b1: { [x: string]: string; } +>b1 : { [x: string]: string; } +>x : string + +a = b1; // error +>a = b1 : { [x: string]: string; } +>a : any +>b1 : { [x: string]: string; } + +b1 = a; // error +>b1 = a : any +>b1 : { [x: string]: string; } +>a : any + +module Generics { +>Generics : typeof Generics + + class A { +>A : A +>T : T +>Derived : Derived + + [x: string]: T; +>x : string +>T : T + } + + function foo() { +>foo : () => void +>T : T +>Derived : Derived + + var a: A; +>a : A +>A : A +>T : T + + var b: { [x: string]: string; } +>b : { [x: string]: string; } +>x : string + + a = b; // error +>a = b : { [x: string]: string; } +>a : A +>b : { [x: string]: string; } + + b = a; // error +>b = a : A +>b : { [x: string]: string; } +>a : A + } +} diff --git a/tests/baselines/reference/assignmentCompatability11.symbols b/tests/baselines/reference/assignmentCompatability11.symbols new file mode 100644 index 00000000000..f086d046bd0 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability11.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability11.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability11.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability11.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability11.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability11.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability11.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability11.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability11.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability11.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability11.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability11.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability11.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability11.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability11.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability11.ts, 3, 1)) + + export var obj = {two: 1}; +>obj : Symbol(obj, Decl(assignmentCompatability11.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability11.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability11.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability11.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability11.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability11.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability11.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability11.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability11.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability11.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability11.types b/tests/baselines/reference/assignmentCompatability11.types new file mode 100644 index 00000000000..d035fe74084 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability11.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/assignmentCompatability11.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {two: 1}; +>obj : { two: number; } +>{two: 1} : { two: number; } +>two : number +>1 : 1 + + export var __val__obj = obj; +>__val__obj : { two: number; } +>obj : { two: number; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { two: number; } +>__test2__ : typeof __test2__ +>__val__obj : { two: number; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability12.symbols b/tests/baselines/reference/assignmentCompatability12.symbols new file mode 100644 index 00000000000..ed758739991 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability12.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability12.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability12.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability12.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability12.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability12.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability12.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability12.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability12.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability12.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability12.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability12.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability12.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability12.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability12.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability12.ts, 3, 1)) + + export var obj = {one: "1"}; +>obj : Symbol(obj, Decl(assignmentCompatability12.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability12.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability12.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability12.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability12.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability12.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability12.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability12.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability12.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability12.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability12.types b/tests/baselines/reference/assignmentCompatability12.types new file mode 100644 index 00000000000..34e83a7dc44 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability12.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/assignmentCompatability12.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {one: "1"}; +>obj : { one: string; } +>{one: "1"} : { one: string; } +>one : string +>"1" : "1" + + export var __val__obj = obj; +>__val__obj : { one: string; } +>obj : { one: string; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { one: string; } +>__test2__ : typeof __test2__ +>__val__obj : { one: string; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability13.symbols b/tests/baselines/reference/assignmentCompatability13.symbols new file mode 100644 index 00000000000..fbe3a51d0fd --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability13.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability13.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability13.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability13.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability13.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability13.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability13.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability13.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability13.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability13.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability13.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability13.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability13.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability13.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability13.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability13.ts, 3, 1)) + + export var obj = {two: "1"}; +>obj : Symbol(obj, Decl(assignmentCompatability13.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability13.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability13.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability13.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability13.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability13.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability13.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability13.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability13.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability13.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability13.types b/tests/baselines/reference/assignmentCompatability13.types new file mode 100644 index 00000000000..3ee0e4a15b5 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability13.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/assignmentCompatability13.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {two: "1"}; +>obj : { two: string; } +>{two: "1"} : { two: string; } +>two : string +>"1" : "1" + + export var __val__obj = obj; +>__val__obj : { two: string; } +>obj : { two: string; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { two: string; } +>__test2__ : typeof __test2__ +>__val__obj : { two: string; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability14.symbols b/tests/baselines/reference/assignmentCompatability14.symbols new file mode 100644 index 00000000000..8d777292a28 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability14.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability14.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability14.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability14.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability14.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability14.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability14.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability14.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability14.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability14.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability14.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability14.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability14.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability14.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability14.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability14.ts, 3, 1)) + + export var obj = {one: true}; +>obj : Symbol(obj, Decl(assignmentCompatability14.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability14.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability14.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability14.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability14.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability14.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability14.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability14.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability14.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability14.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability14.types b/tests/baselines/reference/assignmentCompatability14.types new file mode 100644 index 00000000000..0eee6b21695 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability14.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/assignmentCompatability14.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {one: true}; +>obj : { one: boolean; } +>{one: true} : { one: boolean; } +>one : boolean +>true : true + + export var __val__obj = obj; +>__val__obj : { one: boolean; } +>obj : { one: boolean; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { one: boolean; } +>__test2__ : typeof __test2__ +>__val__obj : { one: boolean; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability15.symbols b/tests/baselines/reference/assignmentCompatability15.symbols new file mode 100644 index 00000000000..3eb985703c8 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability15.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability15.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability15.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability15.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability15.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability15.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability15.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability15.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability15.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability15.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability15.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability15.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability15.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability15.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability15.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability15.ts, 3, 1)) + + export var obj = {two: true}; +>obj : Symbol(obj, Decl(assignmentCompatability15.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability15.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability15.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability15.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability15.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability15.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability15.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability15.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability15.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability15.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability15.types b/tests/baselines/reference/assignmentCompatability15.types new file mode 100644 index 00000000000..426c55f55dc --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability15.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/assignmentCompatability15.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {two: true}; +>obj : { two: boolean; } +>{two: true} : { two: boolean; } +>two : boolean +>true : true + + export var __val__obj = obj; +>__val__obj : { two: boolean; } +>obj : { two: boolean; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { two: boolean; } +>__test2__ : typeof __test2__ +>__val__obj : { two: boolean; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability16.symbols b/tests/baselines/reference/assignmentCompatability16.symbols new file mode 100644 index 00000000000..a7beb212c21 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability16.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability16.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability16.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability16.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability16.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability16.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability16.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability16.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability16.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability16.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability16.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability16.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability16.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability16.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability16.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability16.ts, 3, 1)) + + export var obj = {one: [1]}; +>obj : Symbol(obj, Decl(assignmentCompatability16.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability16.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability16.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability16.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability16.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability16.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability16.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability16.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability16.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability16.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability16.types b/tests/baselines/reference/assignmentCompatability16.types new file mode 100644 index 00000000000..bc37bd93de6 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability16.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/assignmentCompatability16.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {one: [1]}; +>obj : { one: any[]; } +>{one: [1]} : { one: any[]; } +>one : any[] +>[1] : any[] +>[1] : number[] +>1 : 1 + + export var __val__obj = obj; +>__val__obj : { one: any[]; } +>obj : { one: any[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { one: any[]; } +>__test2__ : typeof __test2__ +>__val__obj : { one: any[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability17.symbols b/tests/baselines/reference/assignmentCompatability17.symbols new file mode 100644 index 00000000000..5affec312e5 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability17.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability17.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability17.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability17.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability17.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability17.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability17.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability17.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability17.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability17.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability17.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability17.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability17.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability17.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability17.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability17.ts, 3, 1)) + + export var obj = {two: [1]}; +>obj : Symbol(obj, Decl(assignmentCompatability17.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability17.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability17.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability17.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability17.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability17.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability17.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability17.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability17.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability17.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability17.types b/tests/baselines/reference/assignmentCompatability17.types new file mode 100644 index 00000000000..b6d6854d8a9 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability17.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/assignmentCompatability17.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {two: [1]}; +>obj : { two: any[]; } +>{two: [1]} : { two: any[]; } +>two : any[] +>[1] : any[] +>[1] : number[] +>1 : 1 + + export var __val__obj = obj; +>__val__obj : { two: any[]; } +>obj : { two: any[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { two: any[]; } +>__test2__ : typeof __test2__ +>__val__obj : { two: any[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability18.symbols b/tests/baselines/reference/assignmentCompatability18.symbols new file mode 100644 index 00000000000..4dfdba13873 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability18.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability18.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability18.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability18.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability18.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability18.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability18.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability18.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability18.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability18.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability18.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability18.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability18.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability18.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability18.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability18.ts, 3, 1)) + + export var obj = {one: [1]}; +>obj : Symbol(obj, Decl(assignmentCompatability18.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability18.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability18.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability18.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability18.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability18.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability18.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability18.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability18.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability18.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability18.types b/tests/baselines/reference/assignmentCompatability18.types new file mode 100644 index 00000000000..cae2094c992 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability18.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability18.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {one: [1]}; +>obj : { one: number[]; } +>{one: [1]} : { one: number[]; } +>one : number[] +>[1] : number[] +>1 : 1 + + export var __val__obj = obj; +>__val__obj : { one: number[]; } +>obj : { one: number[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { one: number[]; } +>__test2__ : typeof __test2__ +>__val__obj : { one: number[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability19.symbols b/tests/baselines/reference/assignmentCompatability19.symbols new file mode 100644 index 00000000000..bb6aa900441 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability19.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability19.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability19.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability19.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability19.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability19.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability19.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability19.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability19.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability19.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability19.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability19.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability19.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability19.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability19.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability19.ts, 3, 1)) + + export var obj = {two: [1]}; +>obj : Symbol(obj, Decl(assignmentCompatability19.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability19.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability19.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability19.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability19.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability19.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability19.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability19.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability19.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability19.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability19.types b/tests/baselines/reference/assignmentCompatability19.types new file mode 100644 index 00000000000..41fad382aa5 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability19.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability19.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {two: [1]}; +>obj : { two: number[]; } +>{two: [1]} : { two: number[]; } +>two : number[] +>[1] : number[] +>1 : 1 + + export var __val__obj = obj; +>__val__obj : { two: number[]; } +>obj : { two: number[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { two: number[]; } +>__test2__ : typeof __test2__ +>__val__obj : { two: number[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability20.symbols b/tests/baselines/reference/assignmentCompatability20.symbols new file mode 100644 index 00000000000..e3572bf81d4 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability20.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability20.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability20.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability20.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability20.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability20.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability20.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability20.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability20.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability20.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability20.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability20.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability20.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability20.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability20.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability20.ts, 3, 1)) + + export var obj = {one: ["1"]}; +>obj : Symbol(obj, Decl(assignmentCompatability20.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability20.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability20.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability20.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability20.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability20.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability20.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability20.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability20.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability20.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability20.types b/tests/baselines/reference/assignmentCompatability20.types new file mode 100644 index 00000000000..666ad22e681 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability20.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability20.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {one: ["1"]}; +>obj : { one: string[]; } +>{one: ["1"]} : { one: string[]; } +>one : string[] +>["1"] : string[] +>"1" : "1" + + export var __val__obj = obj; +>__val__obj : { one: string[]; } +>obj : { one: string[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { one: string[]; } +>__test2__ : typeof __test2__ +>__val__obj : { one: string[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability21.symbols b/tests/baselines/reference/assignmentCompatability21.symbols new file mode 100644 index 00000000000..184844b5885 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability21.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability21.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability21.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability21.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability21.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability21.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability21.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability21.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability21.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability21.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability21.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability21.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability21.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability21.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability21.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability21.ts, 3, 1)) + + export var obj = {two: ["1"]}; +>obj : Symbol(obj, Decl(assignmentCompatability21.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability21.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability21.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability21.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability21.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability21.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability21.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability21.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability21.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability21.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability21.types b/tests/baselines/reference/assignmentCompatability21.types new file mode 100644 index 00000000000..2b0c8e90b7b --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability21.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability21.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {two: ["1"]}; +>obj : { two: string[]; } +>{two: ["1"]} : { two: string[]; } +>two : string[] +>["1"] : string[] +>"1" : "1" + + export var __val__obj = obj; +>__val__obj : { two: string[]; } +>obj : { two: string[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { two: string[]; } +>__test2__ : typeof __test2__ +>__val__obj : { two: string[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability22.symbols b/tests/baselines/reference/assignmentCompatability22.symbols new file mode 100644 index 00000000000..457d367ebca --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability22.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability22.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability22.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability22.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability22.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability22.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability22.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability22.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability22.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability22.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability22.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability22.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability22.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability22.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability22.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability22.ts, 3, 1)) + + export var obj = {one: [true]}; +>obj : Symbol(obj, Decl(assignmentCompatability22.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability22.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability22.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability22.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability22.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability22.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability22.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability22.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability22.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability22.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability22.types b/tests/baselines/reference/assignmentCompatability22.types new file mode 100644 index 00000000000..d94f7b51ee7 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability22.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability22.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {one: [true]}; +>obj : { one: boolean[]; } +>{one: [true]} : { one: boolean[]; } +>one : boolean[] +>[true] : boolean[] +>true : true + + export var __val__obj = obj; +>__val__obj : { one: boolean[]; } +>obj : { one: boolean[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { one: boolean[]; } +>__test2__ : typeof __test2__ +>__val__obj : { one: boolean[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability23.symbols b/tests/baselines/reference/assignmentCompatability23.symbols new file mode 100644 index 00000000000..6c42276e49a --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability23.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability23.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability23.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability23.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability23.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability23.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability23.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability23.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability23.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability23.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability23.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability23.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability23.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability23.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability23.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability23.ts, 3, 1)) + + export var obj = {two: [true]}; +>obj : Symbol(obj, Decl(assignmentCompatability23.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability23.ts, 5, 22)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability23.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability23.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability23.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability23.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability23.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability23.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability23.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability23.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability23.types b/tests/baselines/reference/assignmentCompatability23.types new file mode 100644 index 00000000000..8c3f1155f71 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability23.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability23.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = {two: [true]}; +>obj : { two: boolean[]; } +>{two: [true]} : { two: boolean[]; } +>two : boolean[] +>[true] : boolean[] +>true : true + + export var __val__obj = obj; +>__val__obj : { two: boolean[]; } +>obj : { two: boolean[]; } +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : { two: boolean[]; } +>__test2__ : typeof __test2__ +>__val__obj : { two: boolean[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability24.symbols b/tests/baselines/reference/assignmentCompatability24.symbols new file mode 100644 index 00000000000..43914094463 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability24.symbols @@ -0,0 +1,43 @@ +=== tests/cases/compiler/assignmentCompatability24.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability24.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability24.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability24.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability24.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability24.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability24.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability24.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability24.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability24.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability24.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability24.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability24.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability24.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability24.ts, 3, 1)) + + export var obj = function f(a: Tstring) { return a; };; +>obj : Symbol(obj, Decl(assignmentCompatability24.ts, 5, 14)) +>f : Symbol(f, Decl(assignmentCompatability24.ts, 5, 20)) +>Tstring : Symbol(Tstring, Decl(assignmentCompatability24.ts, 5, 32)) +>a : Symbol(a, Decl(assignmentCompatability24.ts, 5, 41)) +>Tstring : Symbol(Tstring, Decl(assignmentCompatability24.ts, 5, 32)) +>a : Symbol(a, Decl(assignmentCompatability24.ts, 5, 41)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability24.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability24.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability24.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability24.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability24.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability24.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability24.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability24.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability24.types b/tests/baselines/reference/assignmentCompatability24.types new file mode 100644 index 00000000000..63fccee0c1c --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability24.types @@ -0,0 +1,47 @@ +=== tests/cases/compiler/assignmentCompatability24.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj = function f(a: Tstring) { return a; };; +>obj : (a: Tstring) => Tstring +>function f(a: Tstring) { return a; } : (a: Tstring) => Tstring +>f : (a: Tstring) => Tstring +>Tstring : Tstring +>a : Tstring +>Tstring : Tstring +>a : Tstring + + export var __val__obj = obj; +>__val__obj : (a: Tstring) => Tstring +>obj : (a: Tstring) => Tstring +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : (a: Tstring) => Tstring +>__test2__ : typeof __test2__ +>__val__obj : (a: Tstring) => Tstring +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability25.symbols b/tests/baselines/reference/assignmentCompatability25.symbols new file mode 100644 index 00000000000..c161232a2dd --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability25.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability25.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability25.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability25.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability25.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability25.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability25.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability25.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability25.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability25.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability25.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability25.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability25.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability25.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability25.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability25.ts, 3, 1)) + + export var aa:{two:number;};; +>aa : Symbol(aa, Decl(assignmentCompatability25.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability25.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability25.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability25.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability25.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability25.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability25.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability25.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability25.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability25.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability25.types b/tests/baselines/reference/assignmentCompatability25.types new file mode 100644 index 00000000000..3f24a798d65 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability25.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability25.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{two:number;};; +>aa : { two: number; } +>two : number + + export var __val__aa = aa; +>__val__aa : { two: number; } +>aa : { two: number; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { two: number; } +>__test2__ : typeof __test2__ +>__val__aa : { two: number; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability26.symbols b/tests/baselines/reference/assignmentCompatability26.symbols new file mode 100644 index 00000000000..83286055c81 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability26.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability26.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability26.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability26.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability26.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability26.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability26.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability26.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability26.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability26.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability26.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability26.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability26.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability26.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability26.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability26.ts, 3, 1)) + + export var aa:{one:string;};; +>aa : Symbol(aa, Decl(assignmentCompatability26.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability26.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability26.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability26.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability26.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability26.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability26.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability26.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability26.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability26.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability26.types b/tests/baselines/reference/assignmentCompatability26.types new file mode 100644 index 00000000000..9653a606705 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability26.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability26.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{one:string;};; +>aa : { one: string; } +>one : string + + export var __val__aa = aa; +>__val__aa : { one: string; } +>aa : { one: string; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { one: string; } +>__test2__ : typeof __test2__ +>__val__aa : { one: string; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability27.symbols b/tests/baselines/reference/assignmentCompatability27.symbols new file mode 100644 index 00000000000..a0d12446512 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability27.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability27.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability27.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability27.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability27.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability27.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability27.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability27.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability27.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability27.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability27.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability27.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability27.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability27.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability27.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability27.ts, 3, 1)) + + export var aa:{two:string;};; +>aa : Symbol(aa, Decl(assignmentCompatability27.ts, 5, 14)) +>two : Symbol(two, Decl(assignmentCompatability27.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability27.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability27.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability27.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability27.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability27.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability27.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability27.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability27.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability27.types b/tests/baselines/reference/assignmentCompatability27.types new file mode 100644 index 00000000000..c04554e5764 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability27.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability27.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{two:string;};; +>aa : { two: string; } +>two : string + + export var __val__aa = aa; +>__val__aa : { two: string; } +>aa : { two: string; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { two: string; } +>__test2__ : typeof __test2__ +>__val__aa : { two: string; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability28.symbols b/tests/baselines/reference/assignmentCompatability28.symbols new file mode 100644 index 00000000000..da7daeb29e1 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability28.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability28.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability28.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability28.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability28.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability28.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability28.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability28.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability28.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability28.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability28.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability28.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability28.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability28.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability28.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability28.ts, 3, 1)) + + export var aa:{one:boolean;};; +>aa : Symbol(aa, Decl(assignmentCompatability28.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability28.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability28.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability28.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability28.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability28.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability28.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability28.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability28.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability28.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability28.types b/tests/baselines/reference/assignmentCompatability28.types new file mode 100644 index 00000000000..bdf277b0664 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability28.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability28.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{one:boolean;};; +>aa : { one: boolean; } +>one : boolean + + export var __val__aa = aa; +>__val__aa : { one: boolean; } +>aa : { one: boolean; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { one: boolean; } +>__test2__ : typeof __test2__ +>__val__aa : { one: boolean; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability29.symbols b/tests/baselines/reference/assignmentCompatability29.symbols new file mode 100644 index 00000000000..0c6aac71681 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability29.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability29.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability29.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability29.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability29.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability29.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability29.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability29.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability29.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability29.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability29.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability29.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability29.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability29.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability29.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability29.ts, 3, 1)) + + export var aa:{one:any[];};; +>aa : Symbol(aa, Decl(assignmentCompatability29.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability29.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability29.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability29.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability29.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability29.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability29.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability29.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability29.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability29.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability29.types b/tests/baselines/reference/assignmentCompatability29.types new file mode 100644 index 00000000000..7a87e4f8bee --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability29.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability29.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{one:any[];};; +>aa : { one: any[]; } +>one : any[] + + export var __val__aa = aa; +>__val__aa : { one: any[]; } +>aa : { one: any[]; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { one: any[]; } +>__test2__ : typeof __test2__ +>__val__aa : { one: any[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability30.symbols b/tests/baselines/reference/assignmentCompatability30.symbols new file mode 100644 index 00000000000..b3e8b43d695 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability30.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability30.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability30.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability30.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability30.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability30.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability30.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability30.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability30.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability30.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability30.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability30.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability30.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability30.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability30.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability30.ts, 3, 1)) + + export var aa:{one:number[];};; +>aa : Symbol(aa, Decl(assignmentCompatability30.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability30.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability30.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability30.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability30.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability30.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability30.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability30.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability30.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability30.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability30.types b/tests/baselines/reference/assignmentCompatability30.types new file mode 100644 index 00000000000..ca541edb554 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability30.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability30.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{one:number[];};; +>aa : { one: number[]; } +>one : number[] + + export var __val__aa = aa; +>__val__aa : { one: number[]; } +>aa : { one: number[]; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { one: number[]; } +>__test2__ : typeof __test2__ +>__val__aa : { one: number[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability31.symbols b/tests/baselines/reference/assignmentCompatability31.symbols new file mode 100644 index 00000000000..e7b453941cc --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability31.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability31.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability31.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability31.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability31.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability31.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability31.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability31.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability31.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability31.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability31.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability31.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability31.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability31.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability31.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability31.ts, 3, 1)) + + export var aa:{one:string[];};; +>aa : Symbol(aa, Decl(assignmentCompatability31.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability31.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability31.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability31.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability31.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability31.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability31.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability31.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability31.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability31.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability31.types b/tests/baselines/reference/assignmentCompatability31.types new file mode 100644 index 00000000000..2c4ec726bcb --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability31.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability31.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{one:string[];};; +>aa : { one: string[]; } +>one : string[] + + export var __val__aa = aa; +>__val__aa : { one: string[]; } +>aa : { one: string[]; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { one: string[]; } +>__test2__ : typeof __test2__ +>__val__aa : { one: string[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability32.symbols b/tests/baselines/reference/assignmentCompatability32.symbols new file mode 100644 index 00000000000..b4d1da0e520 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability32.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability32.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability32.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability32.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability32.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability32.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability32.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability32.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability32.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability32.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability32.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability32.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability32.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability32.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability32.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability32.ts, 3, 1)) + + export var aa:{one:boolean[];};; +>aa : Symbol(aa, Decl(assignmentCompatability32.ts, 5, 14)) +>one : Symbol(one, Decl(assignmentCompatability32.ts, 5, 19)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability32.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability32.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability32.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability32.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability32.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability32.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability32.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability32.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability32.types b/tests/baselines/reference/assignmentCompatability32.types new file mode 100644 index 00000000000..e7e9c3ef929 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability32.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability32.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{one:boolean[];};; +>aa : { one: boolean[]; } +>one : boolean[] + + export var __val__aa = aa; +>__val__aa : { one: boolean[]; } +>aa : { one: boolean[]; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { one: boolean[]; } +>__test2__ : typeof __test2__ +>__val__aa : { one: boolean[]; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability33.symbols b/tests/baselines/reference/assignmentCompatability33.symbols new file mode 100644 index 00000000000..fb6e8d9d5cd --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability33.symbols @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability33.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability33.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability33.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability33.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability33.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability33.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability33.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability33.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability33.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability33.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability33.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability33.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability33.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability33.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability33.ts, 3, 1)) + + export var obj: { (a: Tstring): Tstring; }; +>obj : Symbol(obj, Decl(assignmentCompatability33.ts, 5, 14)) +>Tstring : Symbol(Tstring, Decl(assignmentCompatability33.ts, 5, 23)) +>a : Symbol(a, Decl(assignmentCompatability33.ts, 5, 32)) +>Tstring : Symbol(Tstring, Decl(assignmentCompatability33.ts, 5, 23)) +>Tstring : Symbol(Tstring, Decl(assignmentCompatability33.ts, 5, 23)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability33.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability33.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability33.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability33.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability33.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability33.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability33.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability33.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability33.types b/tests/baselines/reference/assignmentCompatability33.types new file mode 100644 index 00000000000..9420c0f1bc9 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability33.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability33.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj: { (a: Tstring): Tstring; }; +>obj : (a: Tstring) => Tstring +>Tstring : Tstring +>a : Tstring +>Tstring : Tstring +>Tstring : Tstring + + export var __val__obj = obj; +>__val__obj : (a: Tstring) => Tstring +>obj : (a: Tstring) => Tstring +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : (a: Tstring) => Tstring +>__test2__ : typeof __test2__ +>__val__obj : (a: Tstring) => Tstring +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability34.symbols b/tests/baselines/reference/assignmentCompatability34.symbols new file mode 100644 index 00000000000..b6bca968e33 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability34.symbols @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability34.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability34.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability34.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability34.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability34.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability34.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability34.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability34.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability34.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability34.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability34.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability34.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability34.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability34.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability34.ts, 3, 1)) + + export var obj: { (a:Tnumber):Tnumber;}; +>obj : Symbol(obj, Decl(assignmentCompatability34.ts, 5, 14)) +>Tnumber : Symbol(Tnumber, Decl(assignmentCompatability34.ts, 5, 23)) +>a : Symbol(a, Decl(assignmentCompatability34.ts, 5, 32)) +>Tnumber : Symbol(Tnumber, Decl(assignmentCompatability34.ts, 5, 23)) +>Tnumber : Symbol(Tnumber, Decl(assignmentCompatability34.ts, 5, 23)) + + export var __val__obj = obj; +>__val__obj : Symbol(__val__obj, Decl(assignmentCompatability34.ts, 6, 14)) +>obj : Symbol(obj, Decl(assignmentCompatability34.ts, 5, 14)) +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability34.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability34.ts, 3, 1)) +>__val__obj : Symbol(__test2__.__val__obj, Decl(assignmentCompatability34.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability34.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability34.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability34.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability34.types b/tests/baselines/reference/assignmentCompatability34.types new file mode 100644 index 00000000000..323dd84c787 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability34.types @@ -0,0 +1,45 @@ +=== tests/cases/compiler/assignmentCompatability34.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var obj: { (a:Tnumber):Tnumber;}; +>obj : (a: Tnumber) => Tnumber +>Tnumber : Tnumber +>a : Tnumber +>Tnumber : Tnumber +>Tnumber : Tnumber + + export var __val__obj = obj; +>__val__obj : (a: Tnumber) => Tnumber +>obj : (a: Tnumber) => Tnumber +} +__test2__.__val__obj = __test1__.__val__obj4 +>__test2__.__val__obj = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj : (a: Tnumber) => Tnumber +>__test2__ : typeof __test2__ +>__val__obj : (a: Tnumber) => Tnumber +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability35.symbols b/tests/baselines/reference/assignmentCompatability35.symbols new file mode 100644 index 00000000000..04910af5eb6 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability35.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentCompatability35.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability35.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability35.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability35.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability35.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability35.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability35.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability35.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability35.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability35.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability35.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability35.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability35.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability35.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability35.ts, 3, 1)) + + export var aa:{[index:number]:number;};; +>aa : Symbol(aa, Decl(assignmentCompatability35.ts, 5, 14)) +>index : Symbol(index, Decl(assignmentCompatability35.ts, 5, 20)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability35.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability35.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability35.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability35.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability35.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability35.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability35.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability35.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability35.types b/tests/baselines/reference/assignmentCompatability35.types new file mode 100644 index 00000000000..50da60fd0d9 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability35.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/assignmentCompatability35.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{[index:number]:number;};; +>aa : { [index: number]: number; } +>index : number + + export var __val__aa = aa; +>__val__aa : { [index: number]: number; } +>aa : { [index: number]: number; } +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : { [index: number]: number; } +>__test2__ : typeof __test2__ +>__val__aa : { [index: number]: number; } +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability37.symbols b/tests/baselines/reference/assignmentCompatability37.symbols new file mode 100644 index 00000000000..3be2f9df6d3 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability37.symbols @@ -0,0 +1,41 @@ +=== tests/cases/compiler/assignmentCompatability37.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability37.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability37.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability37.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability37.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability37.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability37.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability37.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability37.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability37.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability37.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability37.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability37.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability37.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability37.ts, 3, 1)) + + export var aa:{ new (param: Tnumber); };; +>aa : Symbol(aa, Decl(assignmentCompatability37.ts, 5, 14)) +>Tnumber : Symbol(Tnumber, Decl(assignmentCompatability37.ts, 5, 25)) +>param : Symbol(param, Decl(assignmentCompatability37.ts, 5, 34)) +>Tnumber : Symbol(Tnumber, Decl(assignmentCompatability37.ts, 5, 25)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability37.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability37.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability37.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability37.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability37.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability37.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability37.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability37.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability37.types b/tests/baselines/reference/assignmentCompatability37.types new file mode 100644 index 00000000000..44f1b7d120b --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability37.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/assignmentCompatability37.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{ new (param: Tnumber); };; +>aa : new (param: Tnumber) => any +>Tnumber : Tnumber +>param : Tnumber +>Tnumber : Tnumber + + export var __val__aa = aa; +>__val__aa : new (param: Tnumber) => any +>aa : new (param: Tnumber) => any +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : new (param: Tnumber) => any +>__test2__ : typeof __test2__ +>__val__aa : new (param: Tnumber) => any +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability38.symbols b/tests/baselines/reference/assignmentCompatability38.symbols new file mode 100644 index 00000000000..e5575900d99 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability38.symbols @@ -0,0 +1,41 @@ +=== tests/cases/compiler/assignmentCompatability38.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability38.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability38.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability38.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability38.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability38.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability38.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability38.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability38.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability38.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability38.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability38.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability38.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability38.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability38.ts, 3, 1)) + + export var aa:{ new (param: Tstring); };; +>aa : Symbol(aa, Decl(assignmentCompatability38.ts, 5, 14)) +>Tstring : Symbol(Tstring, Decl(assignmentCompatability38.ts, 5, 25)) +>param : Symbol(param, Decl(assignmentCompatability38.ts, 5, 34)) +>Tstring : Symbol(Tstring, Decl(assignmentCompatability38.ts, 5, 25)) + + export var __val__aa = aa; +>__val__aa : Symbol(__val__aa, Decl(assignmentCompatability38.ts, 6, 14)) +>aa : Symbol(aa, Decl(assignmentCompatability38.ts, 5, 14)) +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability38.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability38.ts, 3, 1)) +>__val__aa : Symbol(__test2__.__val__aa, Decl(assignmentCompatability38.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability38.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability38.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability38.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability38.types b/tests/baselines/reference/assignmentCompatability38.types new file mode 100644 index 00000000000..ae23533fb08 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability38.types @@ -0,0 +1,44 @@ +=== tests/cases/compiler/assignmentCompatability38.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export var aa:{ new (param: Tstring); };; +>aa : new (param: Tstring) => any +>Tstring : Tstring +>param : Tstring +>Tstring : Tstring + + export var __val__aa = aa; +>__val__aa : new (param: Tstring) => any +>aa : new (param: Tstring) => any +} +__test2__.__val__aa = __test1__.__val__obj4 +>__test2__.__val__aa = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__aa : new (param: Tstring) => any +>__test2__ : typeof __test2__ +>__val__aa : new (param: Tstring) => any +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability39.symbols b/tests/baselines/reference/assignmentCompatability39.symbols new file mode 100644 index 00000000000..e015316facc --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability39.symbols @@ -0,0 +1,46 @@ +=== tests/cases/compiler/assignmentCompatability39.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability39.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability39.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability39.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability39.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability39.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability39.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability39.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability39.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability39.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability39.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability39.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability39.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability39.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability39.ts, 3, 1)) + + export class classWithTwoPublic { constructor(public one: T, public two: U) {} } var x2 = new classWithTwoPublic(1, "a");; +>classWithTwoPublic : Symbol(classWithTwoPublic, Decl(assignmentCompatability39.ts, 4, 18)) +>T : Symbol(T, Decl(assignmentCompatability39.ts, 5, 44)) +>U : Symbol(U, Decl(assignmentCompatability39.ts, 5, 46)) +>one : Symbol(classWithTwoPublic.one, Decl(assignmentCompatability39.ts, 5, 63)) +>T : Symbol(T, Decl(assignmentCompatability39.ts, 5, 44)) +>two : Symbol(classWithTwoPublic.two, Decl(assignmentCompatability39.ts, 5, 77)) +>U : Symbol(U, Decl(assignmentCompatability39.ts, 5, 46)) +>x2 : Symbol(x2, Decl(assignmentCompatability39.ts, 5, 104)) +>classWithTwoPublic : Symbol(classWithTwoPublic, Decl(assignmentCompatability39.ts, 4, 18)) + + export var __val__x2 = x2; +>__val__x2 : Symbol(__val__x2, Decl(assignmentCompatability39.ts, 6, 14)) +>x2 : Symbol(x2, Decl(assignmentCompatability39.ts, 5, 104)) +} +__test2__.__val__x2 = __test1__.__val__obj4 +>__test2__.__val__x2 : Symbol(__test2__.__val__x2, Decl(assignmentCompatability39.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability39.ts, 3, 1)) +>__val__x2 : Symbol(__test2__.__val__x2, Decl(assignmentCompatability39.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability39.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability39.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability39.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability39.types b/tests/baselines/reference/assignmentCompatability39.types new file mode 100644 index 00000000000..9621c62d07c --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability39.types @@ -0,0 +1,52 @@ +=== tests/cases/compiler/assignmentCompatability39.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export class classWithTwoPublic { constructor(public one: T, public two: U) {} } var x2 = new classWithTwoPublic(1, "a");; +>classWithTwoPublic : classWithTwoPublic +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>x2 : classWithTwoPublic +>new classWithTwoPublic(1, "a") : classWithTwoPublic +>classWithTwoPublic : typeof classWithTwoPublic +>1 : 1 +>"a" : "a" + + export var __val__x2 = x2; +>__val__x2 : classWithTwoPublic +>x2 : classWithTwoPublic +} +__test2__.__val__x2 = __test1__.__val__obj4 +>__test2__.__val__x2 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__x2 : __test2__.classWithTwoPublic +>__test2__ : typeof __test2__ +>__val__x2 : __test2__.classWithTwoPublic +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability40.symbols b/tests/baselines/reference/assignmentCompatability40.symbols new file mode 100644 index 00000000000..177c83e3d62 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability40.symbols @@ -0,0 +1,43 @@ +=== tests/cases/compiler/assignmentCompatability40.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability40.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability40.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability40.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability40.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability40.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability40.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability40.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability40.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability40.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability40.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability40.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability40.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability40.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability40.ts, 3, 1)) + + export class classWithPrivate { constructor(private one: T) {} } var x5 = new classWithPrivate(1);; +>classWithPrivate : Symbol(classWithPrivate, Decl(assignmentCompatability40.ts, 4, 18)) +>T : Symbol(T, Decl(assignmentCompatability40.ts, 5, 44)) +>one : Symbol(classWithPrivate.one, Decl(assignmentCompatability40.ts, 5, 61)) +>T : Symbol(T, Decl(assignmentCompatability40.ts, 5, 44)) +>x5 : Symbol(x5, Decl(assignmentCompatability40.ts, 5, 107)) +>classWithPrivate : Symbol(classWithPrivate, Decl(assignmentCompatability40.ts, 4, 18)) + + export var __val__x5 = x5; +>__val__x5 : Symbol(__val__x5, Decl(assignmentCompatability40.ts, 6, 14)) +>x5 : Symbol(x5, Decl(assignmentCompatability40.ts, 5, 107)) +} +__test2__.__val__x5 = __test1__.__val__obj4 +>__test2__.__val__x5 : Symbol(__test2__.__val__x5, Decl(assignmentCompatability40.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability40.ts, 3, 1)) +>__val__x5 : Symbol(__test2__.__val__x5, Decl(assignmentCompatability40.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability40.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability40.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability40.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability40.types b/tests/baselines/reference/assignmentCompatability40.types new file mode 100644 index 00000000000..31a598ffe25 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability40.types @@ -0,0 +1,48 @@ +=== tests/cases/compiler/assignmentCompatability40.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export class classWithPrivate { constructor(private one: T) {} } var x5 = new classWithPrivate(1);; +>classWithPrivate : classWithPrivate +>T : T +>one : T +>T : T +>x5 : classWithPrivate +>new classWithPrivate(1) : classWithPrivate +>classWithPrivate : typeof classWithPrivate +>1 : 1 + + export var __val__x5 = x5; +>__val__x5 : classWithPrivate +>x5 : classWithPrivate +} +__test2__.__val__x5 = __test1__.__val__obj4 +>__test2__.__val__x5 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__x5 : __test2__.classWithPrivate +>__test2__ : typeof __test2__ +>__val__x5 : __test2__.classWithPrivate +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability41.symbols b/tests/baselines/reference/assignmentCompatability41.symbols new file mode 100644 index 00000000000..22096f56a7d --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability41.symbols @@ -0,0 +1,46 @@ +=== tests/cases/compiler/assignmentCompatability41.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability41.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability41.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability41.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability41.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability41.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability41.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability41.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability41.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability41.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability41.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability41.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability41.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability41.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability41.ts, 3, 1)) + + export class classWithTwoPrivate { constructor(private one: T, private two: U) {} } var x6 = new classWithTwoPrivate(1, "a");; +>classWithTwoPrivate : Symbol(classWithTwoPrivate, Decl(assignmentCompatability41.ts, 4, 18)) +>T : Symbol(T, Decl(assignmentCompatability41.ts, 5, 44)) +>U : Symbol(U, Decl(assignmentCompatability41.ts, 5, 46)) +>one : Symbol(classWithTwoPrivate.one, Decl(assignmentCompatability41.ts, 5, 63)) +>T : Symbol(T, Decl(assignmentCompatability41.ts, 5, 44)) +>two : Symbol(classWithTwoPrivate.two, Decl(assignmentCompatability41.ts, 5, 78)) +>U : Symbol(U, Decl(assignmentCompatability41.ts, 5, 46)) +>x6 : Symbol(x6, Decl(assignmentCompatability41.ts, 5, 104)) +>classWithTwoPrivate : Symbol(classWithTwoPrivate, Decl(assignmentCompatability41.ts, 4, 18)) + + export var __val__x6 = x6; +>__val__x6 : Symbol(__val__x6, Decl(assignmentCompatability41.ts, 6, 14)) +>x6 : Symbol(x6, Decl(assignmentCompatability41.ts, 5, 104)) +} +__test2__.__val__x6 = __test1__.__val__obj4 +>__test2__.__val__x6 : Symbol(__test2__.__val__x6, Decl(assignmentCompatability41.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability41.ts, 3, 1)) +>__val__x6 : Symbol(__test2__.__val__x6, Decl(assignmentCompatability41.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability41.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability41.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability41.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability41.types b/tests/baselines/reference/assignmentCompatability41.types new file mode 100644 index 00000000000..343cd4e81b6 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability41.types @@ -0,0 +1,52 @@ +=== tests/cases/compiler/assignmentCompatability41.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export class classWithTwoPrivate { constructor(private one: T, private two: U) {} } var x6 = new classWithTwoPrivate(1, "a");; +>classWithTwoPrivate : classWithTwoPrivate +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>x6 : classWithTwoPrivate +>new classWithTwoPrivate(1, "a") : classWithTwoPrivate +>classWithTwoPrivate : typeof classWithTwoPrivate +>1 : 1 +>"a" : "a" + + export var __val__x6 = x6; +>__val__x6 : classWithTwoPrivate +>x6 : classWithTwoPrivate +} +__test2__.__val__x6 = __test1__.__val__obj4 +>__test2__.__val__x6 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__x6 : __test2__.classWithTwoPrivate +>__test2__ : typeof __test2__ +>__val__x6 : __test2__.classWithTwoPrivate +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability42.symbols b/tests/baselines/reference/assignmentCompatability42.symbols new file mode 100644 index 00000000000..399e6fab579 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability42.symbols @@ -0,0 +1,46 @@ +=== tests/cases/compiler/assignmentCompatability42.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability42.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability42.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability42.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability42.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability42.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability42.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability42.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability42.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability42.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability42.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability42.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability42.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability42.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability42.ts, 3, 1)) + + export class classWithPublicPrivate { constructor(public one: T, private two: U) {} } var x7 = new classWithPublicPrivate(1, "a");; +>classWithPublicPrivate : Symbol(classWithPublicPrivate, Decl(assignmentCompatability42.ts, 4, 18)) +>T : Symbol(T, Decl(assignmentCompatability42.ts, 5, 44)) +>U : Symbol(U, Decl(assignmentCompatability42.ts, 5, 46)) +>one : Symbol(classWithPublicPrivate.one, Decl(assignmentCompatability42.ts, 5, 63)) +>T : Symbol(T, Decl(assignmentCompatability42.ts, 5, 44)) +>two : Symbol(classWithPublicPrivate.two, Decl(assignmentCompatability42.ts, 5, 77)) +>U : Symbol(U, Decl(assignmentCompatability42.ts, 5, 46)) +>x7 : Symbol(x7, Decl(assignmentCompatability42.ts, 5, 104)) +>classWithPublicPrivate : Symbol(classWithPublicPrivate, Decl(assignmentCompatability42.ts, 4, 18)) + + export var __val__x7 = x7; +>__val__x7 : Symbol(__val__x7, Decl(assignmentCompatability42.ts, 6, 14)) +>x7 : Symbol(x7, Decl(assignmentCompatability42.ts, 5, 104)) +} +__test2__.__val__x7 = __test1__.__val__obj4 +>__test2__.__val__x7 : Symbol(__test2__.__val__x7, Decl(assignmentCompatability42.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability42.ts, 3, 1)) +>__val__x7 : Symbol(__test2__.__val__x7, Decl(assignmentCompatability42.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability42.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability42.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability42.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability42.types b/tests/baselines/reference/assignmentCompatability42.types new file mode 100644 index 00000000000..168d718e1e4 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability42.types @@ -0,0 +1,52 @@ +=== tests/cases/compiler/assignmentCompatability42.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export class classWithPublicPrivate { constructor(public one: T, private two: U) {} } var x7 = new classWithPublicPrivate(1, "a");; +>classWithPublicPrivate : classWithPublicPrivate +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>x7 : classWithPublicPrivate +>new classWithPublicPrivate(1, "a") : classWithPublicPrivate +>classWithPublicPrivate : typeof classWithPublicPrivate +>1 : 1 +>"a" : "a" + + export var __val__x7 = x7; +>__val__x7 : classWithPublicPrivate +>x7 : classWithPublicPrivate +} +__test2__.__val__x7 = __test1__.__val__obj4 +>__test2__.__val__x7 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__x7 : __test2__.classWithPublicPrivate +>__test2__ : typeof __test2__ +>__val__x7 : __test2__.classWithPublicPrivate +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability43.symbols b/tests/baselines/reference/assignmentCompatability43.symbols new file mode 100644 index 00000000000..0b0f1489f1f --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability43.symbols @@ -0,0 +1,48 @@ +=== tests/cases/compiler/assignmentCompatability43.ts === +module __test1__ { +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability43.ts, 0, 0)) + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability43.ts, 0, 18)) +>T : Symbol(T, Decl(assignmentCompatability43.ts, 1, 52)) +>U : Symbol(U, Decl(assignmentCompatability43.ts, 1, 54)) +>one : Symbol(interfaceWithPublicAndOptional.one, Decl(assignmentCompatability43.ts, 1, 58)) +>T : Symbol(T, Decl(assignmentCompatability43.ts, 1, 52)) +>two : Symbol(interfaceWithPublicAndOptional.two, Decl(assignmentCompatability43.ts, 1, 66)) +>U : Symbol(U, Decl(assignmentCompatability43.ts, 1, 54)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability43.ts, 1, 83)) +>interfaceWithPublicAndOptional : Symbol(interfaceWithPublicAndOptional, Decl(assignmentCompatability43.ts, 0, 18)) +>one : Symbol(one, Decl(assignmentCompatability43.ts, 1, 139)) + + export var __val__obj4 = obj4; +>__val__obj4 : Symbol(__val__obj4, Decl(assignmentCompatability43.ts, 2, 14)) +>obj4 : Symbol(obj4, Decl(assignmentCompatability43.ts, 1, 83)) +} +module __test2__ { +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability43.ts, 3, 1)) + + export interface interfaceTwo { one: T; two: U; }; var obj2: interfaceTwo = { one: 1, two: "a" };; +>interfaceTwo : Symbol(interfaceTwo, Decl(assignmentCompatability43.ts, 4, 18)) +>T : Symbol(T, Decl(assignmentCompatability43.ts, 5, 52)) +>U : Symbol(U, Decl(assignmentCompatability43.ts, 5, 54)) +>one : Symbol(interfaceTwo.one, Decl(assignmentCompatability43.ts, 5, 58)) +>T : Symbol(T, Decl(assignmentCompatability43.ts, 5, 52)) +>two : Symbol(interfaceTwo.two, Decl(assignmentCompatability43.ts, 5, 66)) +>U : Symbol(U, Decl(assignmentCompatability43.ts, 5, 54)) +>obj2 : Symbol(obj2, Decl(assignmentCompatability43.ts, 5, 83)) +>interfaceTwo : Symbol(interfaceTwo, Decl(assignmentCompatability43.ts, 4, 18)) +>one : Symbol(one, Decl(assignmentCompatability43.ts, 5, 121)) +>two : Symbol(two, Decl(assignmentCompatability43.ts, 5, 129)) + + export var __val__obj2 = obj2; +>__val__obj2 : Symbol(__val__obj2, Decl(assignmentCompatability43.ts, 6, 14)) +>obj2 : Symbol(obj2, Decl(assignmentCompatability43.ts, 5, 83)) +} +__test2__.__val__obj2 = __test1__.__val__obj4 +>__test2__.__val__obj2 : Symbol(__test2__.__val__obj2, Decl(assignmentCompatability43.ts, 6, 14)) +>__test2__ : Symbol(__test2__, Decl(assignmentCompatability43.ts, 3, 1)) +>__val__obj2 : Symbol(__test2__.__val__obj2, Decl(assignmentCompatability43.ts, 6, 14)) +>__test1__.__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability43.ts, 2, 14)) +>__test1__ : Symbol(__test1__, Decl(assignmentCompatability43.ts, 0, 0)) +>__val__obj4 : Symbol(__test1__.__val__obj4, Decl(assignmentCompatability43.ts, 2, 14)) + diff --git a/tests/baselines/reference/assignmentCompatability43.types b/tests/baselines/reference/assignmentCompatability43.types new file mode 100644 index 00000000000..8693eb35fbe --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability43.types @@ -0,0 +1,54 @@ +=== tests/cases/compiler/assignmentCompatability43.ts === +module __test1__ { +>__test1__ : typeof __test1__ + + export interface interfaceWithPublicAndOptional { one: T; two?: U; }; var obj4: interfaceWithPublicAndOptional = { one: 1 };; +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj4 : interfaceWithPublicAndOptional +>interfaceWithPublicAndOptional : interfaceWithPublicAndOptional +>{ one: 1 } : { one: number; } +>one : number +>1 : 1 + + export var __val__obj4 = obj4; +>__val__obj4 : interfaceWithPublicAndOptional +>obj4 : interfaceWithPublicAndOptional +} +module __test2__ { +>__test2__ : typeof __test2__ + + export interface interfaceTwo { one: T; two: U; }; var obj2: interfaceTwo = { one: 1, two: "a" };; +>interfaceTwo : interfaceTwo +>T : T +>U : U +>one : T +>T : T +>two : U +>U : U +>obj2 : interfaceTwo +>interfaceTwo : interfaceTwo +>{ one: 1, two: "a" } : { one: number; two: string; } +>one : number +>1 : 1 +>two : string +>"a" : "a" + + export var __val__obj2 = obj2; +>__val__obj2 : interfaceTwo +>obj2 : interfaceTwo +} +__test2__.__val__obj2 = __test1__.__val__obj4 +>__test2__.__val__obj2 = __test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test2__.__val__obj2 : __test2__.interfaceTwo +>__test2__ : typeof __test2__ +>__val__obj2 : __test2__.interfaceTwo +>__test1__.__val__obj4 : __test1__.interfaceWithPublicAndOptional +>__test1__ : typeof __test1__ +>__val__obj4 : __test1__.interfaceWithPublicAndOptional + diff --git a/tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.symbols b/tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.symbols new file mode 100644 index 00000000000..b28f7cd682e --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.symbols @@ -0,0 +1,60 @@ +=== tests/cases/compiler/assignmentCompatability_checking-apply-member-off-of-function-interface.ts === +// 3.8.4 Assignment Compatibility + +interface Applicable { +>Applicable : Symbol(Applicable, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 0, 0)) + + apply(blah: any); // also works for 'apply' +>apply : Symbol(Applicable.apply, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 2, 22)) +>blah : Symbol(blah, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 3, 10)) +} + +var x: Applicable; +>x : Symbol(x, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 6, 3)) +>Applicable : Symbol(Applicable, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 0, 0)) + +// Should fail +x = ''; +>x : Symbol(x, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 6, 3)) + +x = ['']; +>x : Symbol(x, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 6, 3)) + +x = 4; +>x : Symbol(x, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 6, 3)) + +x = {}; +>x : Symbol(x, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 6, 3)) + +// Should work +function f() { }; +>f : Symbol(f, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 12, 7)) + +x = f; +>x : Symbol(x, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 12, 7)) + +function fn(c: Applicable) { } +>fn : Symbol(fn, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 16, 6)) +>c : Symbol(c, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 18, 12)) +>Applicable : Symbol(Applicable, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 0, 0)) + +// Should Fail +fn(''); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 16, 6)) + +fn(['']); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 16, 6)) + +fn(4); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 16, 6)) + +fn({}); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 16, 6)) + + +// Should work +fn(a => { }); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 16, 6)) +>a : Symbol(a, Decl(assignmentCompatability_checking-apply-member-off-of-function-interface.ts, 28, 3)) + diff --git a/tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.types b/tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.types new file mode 100644 index 00000000000..8d92d936bad --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability_checking-apply-member-off-of-function-interface.types @@ -0,0 +1,81 @@ +=== tests/cases/compiler/assignmentCompatability_checking-apply-member-off-of-function-interface.ts === +// 3.8.4 Assignment Compatibility + +interface Applicable { +>Applicable : Applicable + + apply(blah: any); // also works for 'apply' +>apply : (blah: any) => any +>blah : any +} + +var x: Applicable; +>x : Applicable +>Applicable : Applicable + +// Should fail +x = ''; +>x = '' : "" +>x : Applicable +>'' : "" + +x = ['']; +>x = [''] : string[] +>x : Applicable +>[''] : string[] +>'' : "" + +x = 4; +>x = 4 : 4 +>x : Applicable +>4 : 4 + +x = {}; +>x = {} : {} +>x : Applicable +>{} : {} + +// Should work +function f() { }; +>f : () => void + +x = f; +>x = f : () => void +>x : Applicable +>f : () => void + +function fn(c: Applicable) { } +>fn : (c: Applicable) => void +>c : Applicable +>Applicable : Applicable + +// Should Fail +fn(''); +>fn('') : void +>fn : (c: Applicable) => void +>'' : "" + +fn(['']); +>fn(['']) : void +>fn : (c: Applicable) => void +>[''] : string[] +>'' : "" + +fn(4); +>fn(4) : void +>fn : (c: Applicable) => void +>4 : 4 + +fn({}); +>fn({}) : void +>fn : (c: Applicable) => void +>{} : {} + + +// Should work +fn(a => { }); +>fn(a => { }) : void +>fn : (c: Applicable) => void +>a => { } : (a: any) => void +>a : any + diff --git a/tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.symbols b/tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.symbols new file mode 100644 index 00000000000..7fe01e7bb76 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.symbols @@ -0,0 +1,60 @@ +=== tests/cases/compiler/assignmentCompatability_checking-call-member-off-of-function-interface.ts === +// 3.8.4 Assignment Compatibility + +interface Callable { +>Callable : Symbol(Callable, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 0, 0)) + + call(blah: any); // also works for 'apply' +>call : Symbol(Callable.call, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 2, 20)) +>blah : Symbol(blah, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 3, 9)) +} + +var x: Callable; +>x : Symbol(x, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 6, 3)) +>Callable : Symbol(Callable, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 0, 0)) + +// Should fail +x = ''; +>x : Symbol(x, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 6, 3)) + +x = ['']; +>x : Symbol(x, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 6, 3)) + +x = 4; +>x : Symbol(x, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 6, 3)) + +x = {}; +>x : Symbol(x, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 6, 3)) + +// Should work +function f() { }; +>f : Symbol(f, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 12, 7)) + +x = f; +>x : Symbol(x, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 6, 3)) +>f : Symbol(f, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 12, 7)) + +function fn(c: Callable) { } +>fn : Symbol(fn, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 16, 6)) +>c : Symbol(c, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 18, 12)) +>Callable : Symbol(Callable, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 0, 0)) + +// Should Fail +fn(''); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 16, 6)) + +fn(['']); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 16, 6)) + +fn(4); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 16, 6)) + +fn({}); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 16, 6)) + + +// Should work +fn(a => { }); +>fn : Symbol(fn, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 16, 6)) +>a : Symbol(a, Decl(assignmentCompatability_checking-call-member-off-of-function-interface.ts, 28, 3)) + diff --git a/tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.types b/tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.types new file mode 100644 index 00000000000..7b512d28fe9 --- /dev/null +++ b/tests/baselines/reference/assignmentCompatability_checking-call-member-off-of-function-interface.types @@ -0,0 +1,81 @@ +=== tests/cases/compiler/assignmentCompatability_checking-call-member-off-of-function-interface.ts === +// 3.8.4 Assignment Compatibility + +interface Callable { +>Callable : Callable + + call(blah: any); // also works for 'apply' +>call : (blah: any) => any +>blah : any +} + +var x: Callable; +>x : Callable +>Callable : Callable + +// Should fail +x = ''; +>x = '' : "" +>x : Callable +>'' : "" + +x = ['']; +>x = [''] : string[] +>x : Callable +>[''] : string[] +>'' : "" + +x = 4; +>x = 4 : 4 +>x : Callable +>4 : 4 + +x = {}; +>x = {} : {} +>x : Callable +>{} : {} + +// Should work +function f() { }; +>f : () => void + +x = f; +>x = f : () => void +>x : Callable +>f : () => void + +function fn(c: Callable) { } +>fn : (c: Callable) => void +>c : Callable +>Callable : Callable + +// Should Fail +fn(''); +>fn('') : void +>fn : (c: Callable) => void +>'' : "" + +fn(['']); +>fn(['']) : void +>fn : (c: Callable) => void +>[''] : string[] +>'' : "" + +fn(4); +>fn(4) : void +>fn : (c: Callable) => void +>4 : 4 + +fn({}); +>fn({}) : void +>fn : (c: Callable) => void +>{} : {} + + +// Should work +fn(a => { }); +>fn(a => { }) : void +>fn : (c: Callable) => void +>a => { } : (a: any) => void +>a : any + diff --git a/tests/baselines/reference/assignmentLHSIsValue.symbols b/tests/baselines/reference/assignmentLHSIsValue.symbols new file mode 100644 index 00000000000..17925257dfb --- /dev/null +++ b/tests/baselines/reference/assignmentLHSIsValue.symbols @@ -0,0 +1,165 @@ +=== tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts === +// expected error for all the LHS of assignments +var value: any; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// this +class C { +>C : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) + + constructor() { this = value; } +>this : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + + foo() { this = value; } +>foo : Symbol(C.foo, Decl(assignmentLHSIsValue.ts, 5, 35)) +>this : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + + static sfoo() { this = value; } +>sfoo : Symbol(C.sfoo, Decl(assignmentLHSIsValue.ts, 6, 27)) +>this : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) +} + +function foo() { this = value; } +>foo : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +this = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// identifiers: module, class, enum, function +module M { export var a; } +>M : Symbol(M, Decl(assignmentLHSIsValue.ts, 12, 13)) +>a : Symbol(a, Decl(assignmentLHSIsValue.ts, 15, 21)) + +M = value; +>M : Symbol(M, Decl(assignmentLHSIsValue.ts, 12, 13)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +C = value; +>C : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +enum E { } +>E : Symbol(E, Decl(assignmentLHSIsValue.ts, 18, 10)) + +E = value; +>E : Symbol(E, Decl(assignmentLHSIsValue.ts, 18, 10)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +foo = value; +>foo : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// literals +null = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +true = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +false = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +0 = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +'' = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +/d+/ = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// object literals +{ a: 0} = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// array literals +['', ''] = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// super +class Derived extends C { +>Derived : Symbol(Derived, Decl(assignmentLHSIsValue.ts, 37, 17)) +>C : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) + + constructor() { super(); super = value; } +>super : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>super : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + + foo() { super = value } +>foo : Symbol(Derived.foo, Decl(assignmentLHSIsValue.ts, 41, 45)) +>super : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + + static sfoo() { super = value; } +>sfoo : Symbol(Derived.sfoo, Decl(assignmentLHSIsValue.ts, 43, 27)) +>super : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) +} + +// function expression +function bar() { } = value; +>bar : Symbol(bar, Decl(assignmentLHSIsValue.ts, 46, 1)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +() => { } = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// function calls +foo() = value; +>foo : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +// parentheses, the containted expression is value +(this) = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(M) = value; +>M : Symbol(M, Decl(assignmentLHSIsValue.ts, 12, 13)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(C) = value; +>C : Symbol(C, Decl(assignmentLHSIsValue.ts, 1, 15)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(E) = value; +>E : Symbol(E, Decl(assignmentLHSIsValue.ts, 18, 10)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(foo) = value; +>foo : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(null) = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(true) = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(0) = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +('') = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(/d+/) = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +({}) = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +([]) = value; +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(function baz() { }) = value; +>baz : Symbol(baz, Decl(assignmentLHSIsValue.ts, 68, 1)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + +(foo()) = value; +>foo : Symbol(foo, Decl(assignmentLHSIsValue.ts, 8, 1)) +>value : Symbol(value, Decl(assignmentLHSIsValue.ts, 1, 3)) + diff --git a/tests/baselines/reference/assignmentLHSIsValue.types b/tests/baselines/reference/assignmentLHSIsValue.types new file mode 100644 index 00000000000..b35c15bfe23 --- /dev/null +++ b/tests/baselines/reference/assignmentLHSIsValue.types @@ -0,0 +1,245 @@ +=== tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts === +// expected error for all the LHS of assignments +var value: any; +>value : any + +// this +class C { +>C : C + + constructor() { this = value; } +>this = value : any +>this : this +>value : any + + foo() { this = value; } +>foo : () => void +>this = value : any +>this : this +>value : any + + static sfoo() { this = value; } +>sfoo : () => void +>this = value : any +>this : typeof C +>value : any +} + +function foo() { this = value; } +>foo : () => void +>this = value : any +>this : any +>value : any + +this = value; +>this = value : any +>this : any +>value : any + +// identifiers: module, class, enum, function +module M { export var a; } +>M : typeof M +>a : any + +M = value; +>M = value : any +>M : any +>value : any + +C = value; +>C = value : any +>C : any +>value : any + +enum E { } +>E : E + +E = value; +>E = value : any +>E : any +>value : any + +foo = value; +>foo = value : any +>foo : any +>value : any + +// literals +null = value; +>null = value : any +>null : null +>value : any + +true = value; +>true = value : any +>true : true +>value : any + +false = value; +>false = value : any +>false : false +>value : any + +0 = value; +>0 = value : any +>0 : 0 +>value : any + +'' = value; +>'' = value : any +>'' : "" +>value : any + +/d+/ = value; +>/d+/ = value : any +>/d+/ : RegExp +>value : any + +// object literals +{ a: 0} = value; +>a : any +>0 : 0 +>value : any + +// array literals +['', ''] = value; +>['', ''] = value : any +>['', ''] : [string, string] +>'' : "" +>'' : "" +>value : any + +// super +class Derived extends C { +>Derived : Derived +>C : C + + constructor() { super(); super = value; } +>super() : void +>super : typeof C +>super = value : any +>super : any +>super : C +> : any +>value : any + + foo() { super = value } +>foo : () => void +>super = value : any +>super : any +>super : C +> : any +>value : any + + static sfoo() { super = value; } +>sfoo : () => void +>super = value : any +>super : any +>super : typeof C +> : any +>value : any +} + +// function expression +function bar() { } = value; +>bar : () => void +>value : any + +() => { } = value; +>() => { } : () => void +>value : any + +// function calls +foo() = value; +>foo() = value : any +>foo() : void +>foo : () => void +>value : any + +// parentheses, the containted expression is value +(this) = value; +>(this) = value : any +>(this) : any +>this : any +>value : any + +(M) = value; +>(M) = value : any +>(M) : any +>M : any +>value : any + +(C) = value; +>(C) = value : any +>(C) : any +>C : any +>value : any + +(E) = value; +>(E) = value : any +>(E) : any +>E : any +>value : any + +(foo) = value; +>(foo) = value : any +>(foo) : any +>foo : any +>value : any + +(null) = value; +>(null) = value : any +>(null) : null +>null : null +>value : any + +(true) = value; +>(true) = value : any +>(true) : true +>true : true +>value : any + +(0) = value; +>(0) = value : any +>(0) : 0 +>0 : 0 +>value : any + +('') = value; +>('') = value : any +>('') : "" +>'' : "" +>value : any + +(/d+/) = value; +>(/d+/) = value : any +>(/d+/) : RegExp +>/d+/ : RegExp +>value : any + +({}) = value; +>({}) = value : any +>({}) : {} +>{} : {} +>value : any + +([]) = value; +>([]) = value : any +>([]) : undefined[] +>[] : undefined[] +>value : any + +(function baz() { }) = value; +>(function baz() { }) = value : any +>(function baz() { }) : () => void +>function baz() { } : () => void +>baz : () => void +>value : any + +(foo()) = value; +>(foo()) = value : any +>(foo()) : void +>foo() : void +>foo : () => void +>value : any + diff --git a/tests/baselines/reference/assignmentRestElementWithErrorSourceType.symbols b/tests/baselines/reference/assignmentRestElementWithErrorSourceType.symbols new file mode 100644 index 00000000000..3b88728b282 --- /dev/null +++ b/tests/baselines/reference/assignmentRestElementWithErrorSourceType.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/assignmentRestElementWithErrorSourceType.ts === +var tuple: [string, number]; +>tuple : Symbol(tuple, Decl(assignmentRestElementWithErrorSourceType.ts, 0, 3)) + +[...c] = tupel; // intentionally misspelled diff --git a/tests/baselines/reference/assignmentRestElementWithErrorSourceType.types b/tests/baselines/reference/assignmentRestElementWithErrorSourceType.types new file mode 100644 index 00000000000..41bdd948d95 --- /dev/null +++ b/tests/baselines/reference/assignmentRestElementWithErrorSourceType.types @@ -0,0 +1,11 @@ +=== tests/cases/compiler/assignmentRestElementWithErrorSourceType.ts === +var tuple: [string, number]; +>tuple : [string, number] + +[...c] = tupel; // intentionally misspelled +>[...c] = tupel : any +>[...c] : undefined[] +>...c : any +>c : any +>tupel : any + diff --git a/tests/baselines/reference/assignmentToFunction.symbols b/tests/baselines/reference/assignmentToFunction.symbols new file mode 100644 index 00000000000..5dc3b673489 --- /dev/null +++ b/tests/baselines/reference/assignmentToFunction.symbols @@ -0,0 +1,20 @@ +=== tests/cases/compiler/assignmentToFunction.ts === +function fn() { } +>fn : Symbol(fn, Decl(assignmentToFunction.ts, 0, 0)) + +fn = () => 3; +>fn : Symbol(fn, Decl(assignmentToFunction.ts, 0, 0)) + +module foo { +>foo : Symbol(foo, Decl(assignmentToFunction.ts, 1, 13)) + + function xyz() { +>xyz : Symbol(xyz, Decl(assignmentToFunction.ts, 3, 12)) + + function bar() { +>bar : Symbol(bar, Decl(assignmentToFunction.ts, 4, 20)) + } + bar = null; +>bar : Symbol(bar, Decl(assignmentToFunction.ts, 4, 20)) + } +} diff --git a/tests/baselines/reference/assignmentToFunction.types b/tests/baselines/reference/assignmentToFunction.types new file mode 100644 index 00000000000..9e3ad6cdb89 --- /dev/null +++ b/tests/baselines/reference/assignmentToFunction.types @@ -0,0 +1,25 @@ +=== tests/cases/compiler/assignmentToFunction.ts === +function fn() { } +>fn : () => void + +fn = () => 3; +>fn = () => 3 : () => number +>fn : any +>() => 3 : () => number +>3 : 3 + +module foo { +>foo : typeof foo + + function xyz() { +>xyz : () => void + + function bar() { +>bar : () => void + } + bar = null; +>bar = null : null +>bar : any +>null : null + } +} diff --git a/tests/baselines/reference/assignmentToObject.symbols b/tests/baselines/reference/assignmentToObject.symbols new file mode 100644 index 00000000000..a087732bc0f --- /dev/null +++ b/tests/baselines/reference/assignmentToObject.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/assignmentToObject.ts === +var a = { toString: 5 }; +>a : Symbol(a, Decl(assignmentToObject.ts, 0, 3)) +>toString : Symbol(toString, Decl(assignmentToObject.ts, 0, 9)) + +var b: {} = a; // ok +>b : Symbol(b, Decl(assignmentToObject.ts, 1, 3)) +>a : Symbol(a, Decl(assignmentToObject.ts, 0, 3)) + +var c: Object = a; // should be error +>c : Symbol(c, Decl(assignmentToObject.ts, 2, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>a : Symbol(a, Decl(assignmentToObject.ts, 0, 3)) + diff --git a/tests/baselines/reference/assignmentToObject.types b/tests/baselines/reference/assignmentToObject.types new file mode 100644 index 00000000000..f39b1210c01 --- /dev/null +++ b/tests/baselines/reference/assignmentToObject.types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/assignmentToObject.ts === +var a = { toString: 5 }; +>a : { toString: number; } +>{ toString: 5 } : { toString: number; } +>toString : number +>5 : 5 + +var b: {} = a; // ok +>b : {} +>a : { toString: number; } + +var c: Object = a; // should be error +>c : Object +>Object : Object +>a : { toString: number; } + diff --git a/tests/baselines/reference/assignmentToObjectAndFunction.symbols b/tests/baselines/reference/assignmentToObjectAndFunction.symbols new file mode 100644 index 00000000000..9beee3b6872 --- /dev/null +++ b/tests/baselines/reference/assignmentToObjectAndFunction.symbols @@ -0,0 +1,69 @@ +=== tests/cases/compiler/assignmentToObjectAndFunction.ts === +var errObj: Object = { toString: 0 }; // Error, incompatible toString +>errObj : Symbol(errObj, Decl(assignmentToObjectAndFunction.ts, 0, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toString : Symbol(toString, Decl(assignmentToObjectAndFunction.ts, 0, 22)) + +var goodObj: Object = { +>goodObj : Symbol(goodObj, Decl(assignmentToObjectAndFunction.ts, 1, 3)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + toString(x?) { +>toString : Symbol(toString, Decl(assignmentToObjectAndFunction.ts, 1, 23)) +>x : Symbol(x, Decl(assignmentToObjectAndFunction.ts, 2, 13)) + + return ""; + } +}; // Ok, because toString is a subtype of Object's toString + +var errFun: Function = {}; // Error for no call signature +>errFun : Symbol(errFun, Decl(assignmentToObjectAndFunction.ts, 7, 3)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +function foo() { } +>foo : Symbol(foo, Decl(assignmentToObjectAndFunction.ts, 7, 26), Decl(assignmentToObjectAndFunction.ts, 9, 18)) + +module foo { +>foo : Symbol(foo, Decl(assignmentToObjectAndFunction.ts, 7, 26), Decl(assignmentToObjectAndFunction.ts, 9, 18)) + + export var boom = 0; +>boom : Symbol(boom, Decl(assignmentToObjectAndFunction.ts, 11, 14)) +} + +var goodFundule: Function = foo; // ok +>goodFundule : Symbol(goodFundule, Decl(assignmentToObjectAndFunction.ts, 14, 3)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>foo : Symbol(foo, Decl(assignmentToObjectAndFunction.ts, 7, 26), Decl(assignmentToObjectAndFunction.ts, 9, 18)) + +function bar() { } +>bar : Symbol(bar, Decl(assignmentToObjectAndFunction.ts, 14, 32), Decl(assignmentToObjectAndFunction.ts, 16, 18)) + +module bar { +>bar : Symbol(bar, Decl(assignmentToObjectAndFunction.ts, 14, 32), Decl(assignmentToObjectAndFunction.ts, 16, 18)) + + export function apply(thisArg: string, argArray?: string) { } +>apply : Symbol(apply, Decl(assignmentToObjectAndFunction.ts, 17, 12)) +>thisArg : Symbol(thisArg, Decl(assignmentToObjectAndFunction.ts, 18, 26)) +>argArray : Symbol(argArray, Decl(assignmentToObjectAndFunction.ts, 18, 42)) +} + +var goodFundule2: Function = bar; // ok +>goodFundule2 : Symbol(goodFundule2, Decl(assignmentToObjectAndFunction.ts, 21, 3)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>bar : Symbol(bar, Decl(assignmentToObjectAndFunction.ts, 14, 32), Decl(assignmentToObjectAndFunction.ts, 16, 18)) + +function bad() { } +>bad : Symbol(bad, Decl(assignmentToObjectAndFunction.ts, 21, 33), Decl(assignmentToObjectAndFunction.ts, 23, 18)) + +module bad { +>bad : Symbol(bad, Decl(assignmentToObjectAndFunction.ts, 21, 33), Decl(assignmentToObjectAndFunction.ts, 23, 18)) + + export var apply = 0; +>apply : Symbol(apply, Decl(assignmentToObjectAndFunction.ts, 25, 14)) +} + +var badFundule: Function = bad; // error +>badFundule : Symbol(badFundule, Decl(assignmentToObjectAndFunction.ts, 28, 3)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>bad : Symbol(bad, Decl(assignmentToObjectAndFunction.ts, 21, 33), Decl(assignmentToObjectAndFunction.ts, 23, 18)) + diff --git a/tests/baselines/reference/assignmentToObjectAndFunction.types b/tests/baselines/reference/assignmentToObjectAndFunction.types new file mode 100644 index 00000000000..d7c6a4f4b12 --- /dev/null +++ b/tests/baselines/reference/assignmentToObjectAndFunction.types @@ -0,0 +1,76 @@ +=== tests/cases/compiler/assignmentToObjectAndFunction.ts === +var errObj: Object = { toString: 0 }; // Error, incompatible toString +>errObj : Object +>Object : Object +>{ toString: 0 } : { toString: number; } +>toString : number +>0 : 0 + +var goodObj: Object = { +>goodObj : Object +>Object : Object +>{ toString(x?) { return ""; }} : { toString(x?: any): string; } + + toString(x?) { +>toString : (x?: any) => string +>x : any + + return ""; +>"" : "" + } +}; // Ok, because toString is a subtype of Object's toString + +var errFun: Function = {}; // Error for no call signature +>errFun : Function +>Function : Function +>{} : {} + +function foo() { } +>foo : typeof foo + +module foo { +>foo : typeof foo + + export var boom = 0; +>boom : number +>0 : 0 +} + +var goodFundule: Function = foo; // ok +>goodFundule : Function +>Function : Function +>foo : typeof foo + +function bar() { } +>bar : typeof bar + +module bar { +>bar : typeof bar + + export function apply(thisArg: string, argArray?: string) { } +>apply : (thisArg: string, argArray?: string) => void +>thisArg : string +>argArray : string +} + +var goodFundule2: Function = bar; // ok +>goodFundule2 : Function +>Function : Function +>bar : typeof bar + +function bad() { } +>bad : typeof bad + +module bad { +>bad : typeof bad + + export var apply = 0; +>apply : number +>0 : 0 +} + +var badFundule: Function = bad; // error +>badFundule : Function +>Function : Function +>bad : typeof bad + diff --git a/tests/baselines/reference/assignmentToParenthesizedExpression1.symbols b/tests/baselines/reference/assignmentToParenthesizedExpression1.symbols new file mode 100644 index 00000000000..63de71a6408 --- /dev/null +++ b/tests/baselines/reference/assignmentToParenthesizedExpression1.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/assignmentToParenthesizedExpression1.ts === +var x; +>x : Symbol(x, Decl(assignmentToParenthesizedExpression1.ts, 0, 3)) + +(1, x)=0; +>x : Symbol(x, Decl(assignmentToParenthesizedExpression1.ts, 0, 3)) + diff --git a/tests/baselines/reference/assignmentToParenthesizedExpression1.types b/tests/baselines/reference/assignmentToParenthesizedExpression1.types new file mode 100644 index 00000000000..a1273376b75 --- /dev/null +++ b/tests/baselines/reference/assignmentToParenthesizedExpression1.types @@ -0,0 +1,12 @@ +=== tests/cases/compiler/assignmentToParenthesizedExpression1.ts === +var x; +>x : any + +(1, x)=0; +>(1, x)=0 : 0 +>(1, x) : any +>1, x : any +>1 : 1 +>x : any +>0 : 0 + diff --git a/tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols b/tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols new file mode 100644 index 00000000000..6330ac20b5f --- /dev/null +++ b/tests/baselines/reference/assignmentToParenthesizedIdentifiers.symbols @@ -0,0 +1,210 @@ +=== tests/cases/conformance/expressions/valuesAndReferences/assignmentToParenthesizedIdentifiers.ts === +var x: number; +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3)) + +x = 3; // OK +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3)) + +(x) = 3; // OK +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3)) + +x = ''; // Error +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3)) + +(x) = ''; // Error +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 0, 3)) + +module M { +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) + + export var y: number; +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) +} +M.y = 3; // OK +>M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) + +(M).y = 3; // OK +>(M).y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) + +(M.y) = 3; // OK +>M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) + +M.y = ''; // Error +>M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) + +(M).y = ''; // Error +>(M).y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) + +(M.y) = ''; // Error +>M.y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(M.y, Decl(assignmentToParenthesizedIdentifiers.ts, 7, 14)) + +M = { y: 3 }; // Error +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 16, 5)) + +(M) = { y: 3 }; // Error +>M : Symbol(M, Decl(assignmentToParenthesizedIdentifiers.ts, 4, 9)) +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 7)) + +module M2 { +>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15)) + + export module M3 { +>M3 : Symbol(M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) + + export var x: number; +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 21, 18)) + } + + M3 = { x: 3 }; // Error +>M3 : Symbol(M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 24, 10)) +} +M2.M3 = { x: 3 }; // OK +>M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15)) +>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 26, 9)) + +(M2).M3 = { x: 3 }; // OK +>(M2).M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15)) +>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 27, 11)) + +(M2.M3) = { x: 3 }; // OK +>M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15)) +>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 28, 11)) + +M2.M3 = { x: '' }; // Error +>M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15)) +>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 30, 9)) + +(M2).M3 = { x: '' }; // Error +>(M2).M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15)) +>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 31, 11)) + +(M2.M3) = { x: '' }; // Error +>M2.M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>M2 : Symbol(M2, Decl(assignmentToParenthesizedIdentifiers.ts, 17, 15)) +>M3 : Symbol(M2.M3, Decl(assignmentToParenthesizedIdentifiers.ts, 19, 11)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 11)) + + +function fn() { } +>fn : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20)) + +fn = () => 3; // Bug 823548: Should be error (fn is not a reference) +>fn : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20)) + +(fn) = () => 3; // Should be error +>fn : Symbol(fn, Decl(assignmentToParenthesizedIdentifiers.ts, 32, 20)) + +function fn2(x: number, y: { t: number }) { +>fn2 : Symbol(fn2, Decl(assignmentToParenthesizedIdentifiers.ts, 37, 15)) +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13)) +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + x = 3; +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13)) + + (x) = 3; // OK +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13)) + + x = ''; // Error +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13)) + + (x) = ''; // Error +>x : Symbol(x, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 13)) + + (y).t = 3; // OK +>(y).t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + (y.t) = 3; // OK +>y.t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + (y).t = ''; // Error +>(y).t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + (y.t) = ''; // Error +>y.t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>t : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + y['t'] = 3; // OK +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + (y)['t'] = 3; // OK +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + (y['t']) = 3; // OK +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + y['t'] = ''; // Error +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + (y)['t'] = ''; // Error +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) + + (y['t']) = ''; // Error +>y : Symbol(y, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 23)) +>'t' : Symbol(t, Decl(assignmentToParenthesizedIdentifiers.ts, 39, 28)) +} + +enum E { +>E : Symbol(E, Decl(assignmentToParenthesizedIdentifiers.ts, 56, 1)) + + A +>A : Symbol(E.A, Decl(assignmentToParenthesizedIdentifiers.ts, 58, 8)) +} +E = undefined; // Error +>E : Symbol(E, Decl(assignmentToParenthesizedIdentifiers.ts, 56, 1)) +>undefined : Symbol(undefined) + +(E) = undefined; // Error +>E : Symbol(E, Decl(assignmentToParenthesizedIdentifiers.ts, 56, 1)) +>undefined : Symbol(undefined) + +class C { +>C : Symbol(C, Decl(assignmentToParenthesizedIdentifiers.ts, 62, 16)) + +} + +C = undefined; // Error +>C : Symbol(C, Decl(assignmentToParenthesizedIdentifiers.ts, 62, 16)) +>undefined : Symbol(undefined) + +(C) = undefined; // Error +>C : Symbol(C, Decl(assignmentToParenthesizedIdentifiers.ts, 62, 16)) +>undefined : Symbol(undefined) + diff --git a/tests/baselines/reference/assignmentToParenthesizedIdentifiers.types b/tests/baselines/reference/assignmentToParenthesizedIdentifiers.types new file mode 100644 index 00000000000..ab95fb8cb2f --- /dev/null +++ b/tests/baselines/reference/assignmentToParenthesizedIdentifiers.types @@ -0,0 +1,325 @@ +=== tests/cases/conformance/expressions/valuesAndReferences/assignmentToParenthesizedIdentifiers.ts === +var x: number; +>x : number + +x = 3; // OK +>x = 3 : 3 +>x : number +>3 : 3 + +(x) = 3; // OK +>(x) = 3 : 3 +>(x) : number +>x : number +>3 : 3 + +x = ''; // Error +>x = '' : "" +>x : number +>'' : "" + +(x) = ''; // Error +>(x) = '' : "" +>(x) : number +>x : number +>'' : "" + +module M { +>M : typeof M + + export var y: number; +>y : number +} +M.y = 3; // OK +>M.y = 3 : 3 +>M.y : number +>M : typeof M +>y : number +>3 : 3 + +(M).y = 3; // OK +>(M).y = 3 : 3 +>(M).y : number +>(M) : typeof M +>M : typeof M +>y : number +>3 : 3 + +(M.y) = 3; // OK +>(M.y) = 3 : 3 +>(M.y) : number +>M.y : number +>M : typeof M +>y : number +>3 : 3 + +M.y = ''; // Error +>M.y = '' : "" +>M.y : number +>M : typeof M +>y : number +>'' : "" + +(M).y = ''; // Error +>(M).y = '' : "" +>(M).y : number +>(M) : typeof M +>M : typeof M +>y : number +>'' : "" + +(M.y) = ''; // Error +>(M.y) = '' : "" +>(M.y) : number +>M.y : number +>M : typeof M +>y : number +>'' : "" + +M = { y: 3 }; // Error +>M = { y: 3 } : { y: number; } +>M : any +>{ y: 3 } : { y: number; } +>y : number +>3 : 3 + +(M) = { y: 3 }; // Error +>(M) = { y: 3 } : { y: number; } +>(M) : any +>M : any +>{ y: 3 } : { y: number; } +>y : number +>3 : 3 + +module M2 { +>M2 : typeof M2 + + export module M3 { +>M3 : typeof M3 + + export var x: number; +>x : number + } + + M3 = { x: 3 }; // Error +>M3 = { x: 3 } : { x: number; } +>M3 : any +>{ x: 3 } : { x: number; } +>x : number +>3 : 3 +} +M2.M3 = { x: 3 }; // OK +>M2.M3 = { x: 3 } : { x: number; } +>M2.M3 : typeof M2.M3 +>M2 : typeof M2 +>M3 : typeof M2.M3 +>{ x: 3 } : { x: number; } +>x : number +>3 : 3 + +(M2).M3 = { x: 3 }; // OK +>(M2).M3 = { x: 3 } : { x: number; } +>(M2).M3 : typeof M2.M3 +>(M2) : typeof M2 +>M2 : typeof M2 +>M3 : typeof M2.M3 +>{ x: 3 } : { x: number; } +>x : number +>3 : 3 + +(M2.M3) = { x: 3 }; // OK +>(M2.M3) = { x: 3 } : { x: number; } +>(M2.M3) : typeof M2.M3 +>M2.M3 : typeof M2.M3 +>M2 : typeof M2 +>M3 : typeof M2.M3 +>{ x: 3 } : { x: number; } +>x : number +>3 : 3 + +M2.M3 = { x: '' }; // Error +>M2.M3 = { x: '' } : { x: string; } +>M2.M3 : typeof M2.M3 +>M2 : typeof M2 +>M3 : typeof M2.M3 +>{ x: '' } : { x: string; } +>x : string +>'' : "" + +(M2).M3 = { x: '' }; // Error +>(M2).M3 = { x: '' } : { x: string; } +>(M2).M3 : typeof M2.M3 +>(M2) : typeof M2 +>M2 : typeof M2 +>M3 : typeof M2.M3 +>{ x: '' } : { x: string; } +>x : string +>'' : "" + +(M2.M3) = { x: '' }; // Error +>(M2.M3) = { x: '' } : { x: string; } +>(M2.M3) : typeof M2.M3 +>M2.M3 : typeof M2.M3 +>M2 : typeof M2 +>M3 : typeof M2.M3 +>{ x: '' } : { x: string; } +>x : string +>'' : "" + + +function fn() { } +>fn : () => void + +fn = () => 3; // Bug 823548: Should be error (fn is not a reference) +>fn = () => 3 : () => number +>fn : any +>() => 3 : () => number +>3 : 3 + +(fn) = () => 3; // Should be error +>(fn) = () => 3 : () => number +>(fn) : any +>fn : any +>() => 3 : () => number +>3 : 3 + +function fn2(x: number, y: { t: number }) { +>fn2 : (x: number, y: { t: number; }) => void +>x : number +>y : { t: number; } +>t : number + + x = 3; +>x = 3 : 3 +>x : number +>3 : 3 + + (x) = 3; // OK +>(x) = 3 : 3 +>(x) : number +>x : number +>3 : 3 + + x = ''; // Error +>x = '' : "" +>x : number +>'' : "" + + (x) = ''; // Error +>(x) = '' : "" +>(x) : number +>x : number +>'' : "" + + (y).t = 3; // OK +>(y).t = 3 : 3 +>(y).t : number +>(y) : { t: number; } +>y : { t: number; } +>t : number +>3 : 3 + + (y.t) = 3; // OK +>(y.t) = 3 : 3 +>(y.t) : number +>y.t : number +>y : { t: number; } +>t : number +>3 : 3 + + (y).t = ''; // Error +>(y).t = '' : "" +>(y).t : number +>(y) : { t: number; } +>y : { t: number; } +>t : number +>'' : "" + + (y.t) = ''; // Error +>(y.t) = '' : "" +>(y.t) : number +>y.t : number +>y : { t: number; } +>t : number +>'' : "" + + y['t'] = 3; // OK +>y['t'] = 3 : 3 +>y['t'] : number +>y : { t: number; } +>'t' : "t" +>3 : 3 + + (y)['t'] = 3; // OK +>(y)['t'] = 3 : 3 +>(y)['t'] : number +>(y) : { t: number; } +>y : { t: number; } +>'t' : "t" +>3 : 3 + + (y['t']) = 3; // OK +>(y['t']) = 3 : 3 +>(y['t']) : number +>y['t'] : number +>y : { t: number; } +>'t' : "t" +>3 : 3 + + y['t'] = ''; // Error +>y['t'] = '' : "" +>y['t'] : number +>y : { t: number; } +>'t' : "t" +>'' : "" + + (y)['t'] = ''; // Error +>(y)['t'] = '' : "" +>(y)['t'] : number +>(y) : { t: number; } +>y : { t: number; } +>'t' : "t" +>'' : "" + + (y['t']) = ''; // Error +>(y['t']) = '' : "" +>(y['t']) : number +>y['t'] : number +>y : { t: number; } +>'t' : "t" +>'' : "" +} + +enum E { +>E : E + + A +>A : E +} +E = undefined; // Error +>E = undefined : undefined +>E : any +>undefined : undefined + +(E) = undefined; // Error +>(E) = undefined : undefined +>(E) : any +>E : any +>undefined : undefined + +class C { +>C : C + +} + +C = undefined; // Error +>C = undefined : undefined +>C : any +>undefined : undefined + +(C) = undefined; // Error +>(C) = undefined : undefined +>(C) : any +>C : any +>undefined : undefined + diff --git a/tests/baselines/reference/assignmentToReferenceTypes.symbols b/tests/baselines/reference/assignmentToReferenceTypes.symbols new file mode 100644 index 00000000000..55a385f0b03 --- /dev/null +++ b/tests/baselines/reference/assignmentToReferenceTypes.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/assignmentToReferenceTypes.ts === +// Should all be allowed + +module M { +>M : Symbol(M, Decl(assignmentToReferenceTypes.ts, 0, 0)) +} +M = null; + +class C { +>C : Symbol(C, Decl(assignmentToReferenceTypes.ts, 4, 9)) +} +C = null; +>C : Symbol(C, Decl(assignmentToReferenceTypes.ts, 4, 9)) + +enum E { +>E : Symbol(E, Decl(assignmentToReferenceTypes.ts, 8, 9)) +} +E = null; +>E : Symbol(E, Decl(assignmentToReferenceTypes.ts, 8, 9)) + +function f() { } +>f : Symbol(f, Decl(assignmentToReferenceTypes.ts, 12, 9)) + +f = null; +>f : Symbol(f, Decl(assignmentToReferenceTypes.ts, 12, 9)) + +var x = 1; +>x : Symbol(x, Decl(assignmentToReferenceTypes.ts, 17, 3)) + +x = null; +>x : Symbol(x, Decl(assignmentToReferenceTypes.ts, 17, 3)) + +function g(x) { +>g : Symbol(g, Decl(assignmentToReferenceTypes.ts, 18, 9)) +>x : Symbol(x, Decl(assignmentToReferenceTypes.ts, 20, 11)) + + x = null; +>x : Symbol(x, Decl(assignmentToReferenceTypes.ts, 20, 11)) +} diff --git a/tests/baselines/reference/assignmentToReferenceTypes.types b/tests/baselines/reference/assignmentToReferenceTypes.types new file mode 100644 index 00000000000..78c5e283368 --- /dev/null +++ b/tests/baselines/reference/assignmentToReferenceTypes.types @@ -0,0 +1,53 @@ +=== tests/cases/compiler/assignmentToReferenceTypes.ts === +// Should all be allowed + +module M { +>M : any +} +M = null; +>M = null : null +>M : any +>null : null + +class C { +>C : C +} +C = null; +>C = null : null +>C : any +>null : null + +enum E { +>E : E +} +E = null; +>E = null : null +>E : any +>null : null + +function f() { } +>f : () => void + +f = null; +>f = null : null +>f : any +>null : null + +var x = 1; +>x : number +>1 : 1 + +x = null; +>x = null : null +>x : number +>null : null + +function g(x) { +>g : (x: any) => void +>x : any + + x = null; +>x = null : null +>x : any +>null : null +} diff --git a/tests/baselines/reference/assignments.symbols b/tests/baselines/reference/assignments.symbols new file mode 100644 index 00000000000..731045c3133 --- /dev/null +++ b/tests/baselines/reference/assignments.symbols @@ -0,0 +1,57 @@ +=== tests/cases/conformance/expressions/valuesAndReferences/assignments.ts === +// 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 : Symbol(M, Decl(assignments.ts, 0, 0)) + +M = null; // Error + +class C { } +>C : Symbol(C, Decl(assignments.ts, 10, 9)) + +C = null; // Error +>C : Symbol(C, Decl(assignments.ts, 10, 9)) + +enum E { A } +>E : Symbol(E, Decl(assignments.ts, 13, 9)) +>A : Symbol(E.A, Decl(assignments.ts, 15, 8)) + +E = null; // Error +>E : Symbol(E, Decl(assignments.ts, 13, 9)) + +E.A = null; // OK per spec, Error per implementation (509581) +>E.A : Symbol(E.A, Decl(assignments.ts, 15, 8)) +>E : Symbol(E, Decl(assignments.ts, 13, 9)) +>A : Symbol(E.A, Decl(assignments.ts, 15, 8)) + +function fn() { } +>fn : Symbol(fn, Decl(assignments.ts, 17, 11)) + +fn = null; // Should be error +>fn : Symbol(fn, Decl(assignments.ts, 17, 11)) + +var v; +>v : Symbol(v, Decl(assignments.ts, 22, 3)) + +v = null; // OK +>v : Symbol(v, Decl(assignments.ts, 22, 3)) + +function fn2(p) { +>fn2 : Symbol(fn2, Decl(assignments.ts, 23, 9)) +>p : Symbol(p, Decl(assignments.ts, 25, 13)) + + p = null; // OK +>p : Symbol(p, Decl(assignments.ts, 25, 13)) +} + +interface I { } +>I : Symbol(I, Decl(assignments.ts, 27, 1)) + +I = null; // Error diff --git a/tests/baselines/reference/assignments.types b/tests/baselines/reference/assignments.types new file mode 100644 index 00000000000..70d034a4101 --- /dev/null +++ b/tests/baselines/reference/assignments.types @@ -0,0 +1,76 @@ +=== tests/cases/conformance/expressions/valuesAndReferences/assignments.ts === +// 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 : any + +M = null; // Error +>M = null : null +>M : any +>null : null + +class C { } +>C : C + +C = null; // Error +>C = null : null +>C : any +>null : null + +enum E { A } +>E : E +>A : E + +E = null; // Error +>E = null : null +>E : any +>null : null + +E.A = null; // OK per spec, Error per implementation (509581) +>E.A = null : null +>E.A : any +>E : typeof E +>A : any +>null : null + +function fn() { } +>fn : () => void + +fn = null; // Should be error +>fn = null : null +>fn : any +>null : null + +var v; +>v : any + +v = null; // OK +>v = null : null +>v : any +>null : null + +function fn2(p) { +>fn2 : (p: any) => void +>p : any + + p = null; // OK +>p = null : null +>p : any +>null : null +} + +interface I { } +>I : I + +I = null; // Error +>I = null : null +>I : any +>null : null + diff --git a/tests/baselines/reference/asyncAliasReturnType_es5.symbols b/tests/baselines/reference/asyncAliasReturnType_es5.symbols index b61fbf6e275..5e024c27d5e 100644 --- a/tests/baselines/reference/asyncAliasReturnType_es5.symbols +++ b/tests/baselines/reference/asyncAliasReturnType_es5.symbols @@ -2,7 +2,7 @@ type PromiseAlias = Promise; >PromiseAlias : Symbol(PromiseAlias, Decl(asyncAliasReturnType_es5.ts, 0, 0)) >T : Symbol(T, Decl(asyncAliasReturnType_es5.ts, 0, 18)) ->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) >T : Symbol(T, Decl(asyncAliasReturnType_es5.ts, 0, 18)) async function f(): PromiseAlias { diff --git a/tests/baselines/reference/asyncArrowFunction10_es2017.symbols b/tests/baselines/reference/asyncArrowFunction10_es2017.symbols new file mode 100644 index 00000000000..dd8516ca0e9 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es2017.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts === +var foo = async (): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction10_es2017.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // Legal to use 'await' in a type context. + var v: await; +>v : Symbol(v, Decl(asyncArrowFunction10_es2017.ts, 2, 6)) +} + diff --git a/tests/baselines/reference/asyncArrowFunction10_es2017.types b/tests/baselines/reference/asyncArrowFunction10_es2017.types new file mode 100644 index 00000000000..b9a95c7189b --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es2017.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction10_es2017.ts === +var foo = async (): Promise => { +>foo : () => Promise +>async (): Promise => { // Legal to use 'await' in a type context. var v: await;} : () => Promise +>Promise : Promise + + // Legal to use 'await' in a type context. + var v: await; +>v : any +>await : No type information available! +} + diff --git a/tests/baselines/reference/asyncArrowFunction10_es5.symbols b/tests/baselines/reference/asyncArrowFunction10_es5.symbols new file mode 100644 index 00000000000..51f63cf481d --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es5.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts === +var foo = async (): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction10_es5.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + // Legal to use 'await' in a type context. + var v: await; +>v : Symbol(v, Decl(asyncArrowFunction10_es5.ts, 2, 6)) +} + diff --git a/tests/baselines/reference/asyncArrowFunction10_es5.types b/tests/baselines/reference/asyncArrowFunction10_es5.types new file mode 100644 index 00000000000..a1c02c7b6fd --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es5.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction10_es5.ts === +var foo = async (): Promise => { +>foo : () => Promise +>async (): Promise => { // Legal to use 'await' in a type context. var v: await;} : () => Promise +>Promise : Promise + + // Legal to use 'await' in a type context. + var v: await; +>v : any +>await : No type information available! +} + diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.symbols b/tests/baselines/reference/asyncArrowFunction10_es6.symbols new file mode 100644 index 00000000000..7962e8328bc --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts === +var foo = async (): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction10_es6.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // Legal to use 'await' in a type context. + var v: await; +>v : Symbol(v, Decl(asyncArrowFunction10_es6.ts, 2, 6)) +} + diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.types b/tests/baselines/reference/asyncArrowFunction10_es6.types new file mode 100644 index 00000000000..85a55d92479 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction10_es6.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts === +var foo = async (): Promise => { +>foo : () => Promise +>async (): Promise => { // Legal to use 'await' in a type context. var v: await;} : () => Promise +>Promise : Promise + + // Legal to use 'await' in a type context. + var v: await; +>v : any +>await : No type information available! +} + diff --git a/tests/baselines/reference/asyncArrowFunction3_es2017.symbols b/tests/baselines/reference/asyncArrowFunction3_es2017.symbols new file mode 100644 index 00000000000..8564be785ab --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es2017.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction3_es2017.ts === +function f(await = await) { +>f : Symbol(f, Decl(asyncArrowFunction3_es2017.ts, 0, 0)) +>await : Symbol(await, Decl(asyncArrowFunction3_es2017.ts, 0, 11)) +>await : Symbol(await, Decl(asyncArrowFunction3_es2017.ts, 0, 11)) +} diff --git a/tests/baselines/reference/asyncArrowFunction3_es2017.types b/tests/baselines/reference/asyncArrowFunction3_es2017.types new file mode 100644 index 00000000000..bd5c2afc67a --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es2017.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction3_es2017.ts === +function f(await = await) { +>f : (await?: any) => void +>await : any +>await : any +} diff --git a/tests/baselines/reference/asyncArrowFunction3_es5.symbols b/tests/baselines/reference/asyncArrowFunction3_es5.symbols new file mode 100644 index 00000000000..f91744bc7fe --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es5.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction3_es5.ts === +function f(await = await) { +>f : Symbol(f, Decl(asyncArrowFunction3_es5.ts, 0, 0)) +>await : Symbol(await, Decl(asyncArrowFunction3_es5.ts, 0, 11)) +>await : Symbol(await, Decl(asyncArrowFunction3_es5.ts, 0, 11)) +} diff --git a/tests/baselines/reference/asyncArrowFunction3_es5.types b/tests/baselines/reference/asyncArrowFunction3_es5.types new file mode 100644 index 00000000000..c4873df1371 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es5.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction3_es5.ts === +function f(await = await) { +>f : (await?: any) => void +>await : any +>await : any +} diff --git a/tests/baselines/reference/asyncArrowFunction3_es6.symbols b/tests/baselines/reference/asyncArrowFunction3_es6.symbols new file mode 100644 index 00000000000..f623c139aa0 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts === +function f(await = await) { +>f : Symbol(f, Decl(asyncArrowFunction3_es6.ts, 0, 0)) +>await : Symbol(await, Decl(asyncArrowFunction3_es6.ts, 0, 11)) +>await : Symbol(await, Decl(asyncArrowFunction3_es6.ts, 0, 11)) +} diff --git a/tests/baselines/reference/asyncArrowFunction3_es6.types b/tests/baselines/reference/asyncArrowFunction3_es6.types new file mode 100644 index 00000000000..c43b50de4ae --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction3_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction3_es6.ts === +function f(await = await) { +>f : (await?: any) => void +>await : any +>await : any +} diff --git a/tests/baselines/reference/asyncArrowFunction5_es2017.symbols b/tests/baselines/reference/asyncArrowFunction5_es2017.symbols new file mode 100644 index 00000000000..9f74f496892 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es2017.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts === +var foo = async (await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction5_es2017.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(asyncArrowFunction5_es2017.ts, 0, 24)) +} diff --git a/tests/baselines/reference/asyncArrowFunction5_es2017.types b/tests/baselines/reference/asyncArrowFunction5_es2017.types new file mode 100644 index 00000000000..95cebf9afba --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es2017.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction5_es2017.ts === +var foo = async (await): Promise => { +>foo : any +>async (await) : any +>async : any +>await : any +>Promise : PromiseConstructor +> : void +> : any +} diff --git a/tests/baselines/reference/asyncArrowFunction5_es5.symbols b/tests/baselines/reference/asyncArrowFunction5_es5.symbols new file mode 100644 index 00000000000..ff2891bb814 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es5.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts === +var foo = async (await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction5_es5.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(asyncArrowFunction5_es5.ts, 0, 24)) +} diff --git a/tests/baselines/reference/asyncArrowFunction5_es5.types b/tests/baselines/reference/asyncArrowFunction5_es5.types new file mode 100644 index 00000000000..93385915415 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es5.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction5_es5.ts === +var foo = async (await): Promise => { +>foo : any +>async (await) : any +>async : any +>await : any +>Promise : PromiseConstructor +> : void +> : any +} diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.symbols b/tests/baselines/reference/asyncArrowFunction5_es6.symbols new file mode 100644 index 00000000000..44827a41f9b --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts === +var foo = async (await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction5_es6.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(asyncArrowFunction5_es6.ts, 0, 24)) +} diff --git a/tests/baselines/reference/asyncArrowFunction5_es6.types b/tests/baselines/reference/asyncArrowFunction5_es6.types new file mode 100644 index 00000000000..1fffb0b1dbd --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction5_es6.types @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction5_es6.ts === +var foo = async (await): Promise => { +>foo : any +>async (await) : any +>async : any +>await : any +>Promise : PromiseConstructor +> : void +> : any +} diff --git a/tests/baselines/reference/asyncArrowFunction6_es2017.symbols b/tests/baselines/reference/asyncArrowFunction6_es2017.symbols new file mode 100644 index 00000000000..c75b45cce81 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es2017.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts === +var foo = async (a = await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction6_es2017.ts, 0, 3)) +>a : Symbol(a, Decl(asyncArrowFunction6_es2017.ts, 0, 17)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncArrowFunction6_es2017.types b/tests/baselines/reference/asyncArrowFunction6_es2017.types new file mode 100644 index 00000000000..d1d8b98944f --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es2017.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction6_es2017.ts === +var foo = async (a = await): Promise => { +>foo : (a?: any) => Promise +>async (a = await): Promise => {} : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncArrowFunction6_es5.symbols b/tests/baselines/reference/asyncArrowFunction6_es5.symbols new file mode 100644 index 00000000000..51f3a218ecc --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es5.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts === +var foo = async (a = await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction6_es5.ts, 0, 3)) +>a : Symbol(a, Decl(asyncArrowFunction6_es5.ts, 0, 17)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncArrowFunction6_es5.types b/tests/baselines/reference/asyncArrowFunction6_es5.types new file mode 100644 index 00000000000..d5458c6bc1c --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es5.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction6_es5.ts === +var foo = async (a = await): Promise => { +>foo : (a?: any) => Promise +>async (a = await): Promise => {} : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.symbols b/tests/baselines/reference/asyncArrowFunction6_es6.symbols new file mode 100644 index 00000000000..e3fa9a191f0 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts === +var foo = async (a = await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction6_es6.ts, 0, 3)) +>a : Symbol(a, Decl(asyncArrowFunction6_es6.ts, 0, 17)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.types b/tests/baselines/reference/asyncArrowFunction6_es6.types new file mode 100644 index 00000000000..66957807462 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction6_es6.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction6_es6.ts === +var foo = async (a = await): Promise => { +>foo : (a?: any) => Promise +>async (a = await): Promise => {} : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncArrowFunction7_es2017.symbols b/tests/baselines/reference/asyncArrowFunction7_es2017.symbols new file mode 100644 index 00000000000..c6e24798e70 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es2017.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts === +var bar = async (): Promise => { +>bar : Symbol(bar, Decl(asyncArrowFunction7_es2017.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction7_es2017.ts, 2, 5)) +>a : Symbol(a, Decl(asyncArrowFunction7_es2017.ts, 2, 19)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + } +} diff --git a/tests/baselines/reference/asyncArrowFunction7_es2017.types b/tests/baselines/reference/asyncArrowFunction7_es2017.types new file mode 100644 index 00000000000..48c2195dec5 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es2017.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction7_es2017.ts === +var bar = async (): Promise => { +>bar : () => Promise +>async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { }} : () => Promise +>Promise : Promise + + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { +>foo : (a?: any) => Promise +>async (a = await): Promise => { } : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise + } +} diff --git a/tests/baselines/reference/asyncArrowFunction7_es5.symbols b/tests/baselines/reference/asyncArrowFunction7_es5.symbols new file mode 100644 index 00000000000..e2cda0a8997 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es5.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts === +var bar = async (): Promise => { +>bar : Symbol(bar, Decl(asyncArrowFunction7_es5.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction7_es5.ts, 2, 5)) +>a : Symbol(a, Decl(asyncArrowFunction7_es5.ts, 2, 19)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } +} diff --git a/tests/baselines/reference/asyncArrowFunction7_es5.types b/tests/baselines/reference/asyncArrowFunction7_es5.types new file mode 100644 index 00000000000..cb468123db7 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es5.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction7_es5.ts === +var bar = async (): Promise => { +>bar : () => Promise +>async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { }} : () => Promise +>Promise : Promise + + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { +>foo : (a?: any) => Promise +>async (a = await): Promise => { } : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise + } +} diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.symbols b/tests/baselines/reference/asyncArrowFunction7_es6.symbols new file mode 100644 index 00000000000..c2d9d8404da --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es6.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts === +var bar = async (): Promise => { +>bar : Symbol(bar, Decl(asyncArrowFunction7_es6.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction7_es6.ts, 2, 5)) +>a : Symbol(a, Decl(asyncArrowFunction7_es6.ts, 2, 19)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + } +} diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.types b/tests/baselines/reference/asyncArrowFunction7_es6.types new file mode 100644 index 00000000000..8687451f03b --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction7_es6.types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction7_es6.ts === +var bar = async (): Promise => { +>bar : () => Promise +>async (): Promise => { // 'await' here is an identifier, and not an await expression. var foo = async (a = await): Promise => { }} : () => Promise +>Promise : Promise + + // 'await' here is an identifier, and not an await expression. + var foo = async (a = await): Promise => { +>foo : (a?: any) => Promise +>async (a = await): Promise => { } : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise + } +} diff --git a/tests/baselines/reference/asyncArrowFunction8_es2017.symbols b/tests/baselines/reference/asyncArrowFunction8_es2017.symbols new file mode 100644 index 00000000000..568416e148c --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es2017.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts === +var foo = async (): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction8_es2017.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + var v = { [await]: foo } +>v : Symbol(v, Decl(asyncArrowFunction8_es2017.ts, 1, 5)) +>foo : Symbol(foo, Decl(asyncArrowFunction8_es2017.ts, 0, 3)) +} diff --git a/tests/baselines/reference/asyncArrowFunction8_es2017.types b/tests/baselines/reference/asyncArrowFunction8_es2017.types new file mode 100644 index 00000000000..62064fe9614 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es2017.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction8_es2017.ts === +var foo = async (): Promise => { +>foo : () => Promise +>async (): Promise => { var v = { [await]: foo }} : () => Promise +>Promise : Promise + + var v = { [await]: foo } +>v : { [x: number]: () => Promise; } +>{ [await]: foo } : { [x: number]: () => Promise; } +>await : any +> : any +>foo : () => Promise +} diff --git a/tests/baselines/reference/asyncArrowFunction8_es5.symbols b/tests/baselines/reference/asyncArrowFunction8_es5.symbols new file mode 100644 index 00000000000..414f2303fe3 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es5.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts === +var foo = async (): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction8_es5.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + var v = { [await]: foo } +>v : Symbol(v, Decl(asyncArrowFunction8_es5.ts, 1, 5)) +>foo : Symbol(foo, Decl(asyncArrowFunction8_es5.ts, 0, 3)) +} diff --git a/tests/baselines/reference/asyncArrowFunction8_es5.types b/tests/baselines/reference/asyncArrowFunction8_es5.types new file mode 100644 index 00000000000..c89bf47b0c6 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es5.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction8_es5.ts === +var foo = async (): Promise => { +>foo : () => Promise +>async (): Promise => { var v = { [await]: foo }} : () => Promise +>Promise : Promise + + var v = { [await]: foo } +>v : { [x: number]: () => Promise; } +>{ [await]: foo } : { [x: number]: () => Promise; } +>await : any +> : any +>foo : () => Promise +} diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.symbols b/tests/baselines/reference/asyncArrowFunction8_es6.symbols new file mode 100644 index 00000000000..47117f2c61c --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es6.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts === +var foo = async (): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction8_es6.ts, 0, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + var v = { [await]: foo } +>v : Symbol(v, Decl(asyncArrowFunction8_es6.ts, 1, 5)) +>foo : Symbol(foo, Decl(asyncArrowFunction8_es6.ts, 0, 3)) +} diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.types b/tests/baselines/reference/asyncArrowFunction8_es6.types new file mode 100644 index 00000000000..aae1a0dcaeb --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction8_es6.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction8_es6.ts === +var foo = async (): Promise => { +>foo : () => Promise +>async (): Promise => { var v = { [await]: foo }} : () => Promise +>Promise : Promise + + var v = { [await]: foo } +>v : { [x: number]: () => Promise; } +>{ [await]: foo } : { [x: number]: () => Promise; } +>await : any +> : any +>foo : () => Promise +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es2017.symbols b/tests/baselines/reference/asyncArrowFunction9_es2017.symbols new file mode 100644 index 00000000000..d15a8d3ee98 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es2017.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction9_es2017.ts === +var foo = async (a = await => await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction9_es2017.ts, 0, 3)) +>await : Symbol(await, Decl(asyncArrowFunction9_es2017.ts, 0, 20)) +>await : Symbol(await, Decl(asyncArrowFunction9_es2017.ts, 0, 20)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(asyncArrowFunction9_es2017.ts, 0, 37)) +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es2017.types b/tests/baselines/reference/asyncArrowFunction9_es2017.types new file mode 100644 index 00000000000..48a29643016 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es2017.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction9_es2017.ts === +var foo = async (a = await => await): Promise => { +>foo : any +>async (a = await => await) : any +>async : any +>a = await => await : (await: any) => any +>a : any +>await => await : (await: any) => any +>await : any +>await : any +>Promise : PromiseConstructor +> : void +> : any +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es5.symbols b/tests/baselines/reference/asyncArrowFunction9_es5.symbols new file mode 100644 index 00000000000..e0e27ba2f75 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es5.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction9_es5.ts === +var foo = async (a = await => await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction9_es5.ts, 0, 3)) +>await : Symbol(await, Decl(asyncArrowFunction9_es5.ts, 0, 20)) +>await : Symbol(await, Decl(asyncArrowFunction9_es5.ts, 0, 20)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(asyncArrowFunction9_es5.ts, 0, 37)) +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es5.types b/tests/baselines/reference/asyncArrowFunction9_es5.types new file mode 100644 index 00000000000..43f685a4e48 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es5.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunction9_es5.ts === +var foo = async (a = await => await): Promise => { +>foo : any +>async (a = await => await) : any +>async : any +>a = await => await : (await: any) => any +>a : any +>await => await : (await: any) => any +>await : any +>await : any +>Promise : PromiseConstructor +> : void +> : any +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.symbols b/tests/baselines/reference/asyncArrowFunction9_es6.symbols new file mode 100644 index 00000000000..6d0506402bb --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts === +var foo = async (a = await => await): Promise => { +>foo : Symbol(foo, Decl(asyncArrowFunction9_es6.ts, 0, 3)) +>await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) +>await : Symbol(await, Decl(asyncArrowFunction9_es6.ts, 0, 20)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(asyncArrowFunction9_es6.ts, 0, 37)) +} diff --git a/tests/baselines/reference/asyncArrowFunction9_es6.types b/tests/baselines/reference/asyncArrowFunction9_es6.types new file mode 100644 index 00000000000..8bfa14b4ff5 --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunction9_es6.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction9_es6.ts === +var foo = async (a = await => await): Promise => { +>foo : any +>async (a = await => await) : any +>async : any +>a = await => await : (await: any) => any +>a : any +>await => await : (await: any) => any +>await : any +>await : any +>Promise : PromiseConstructor +> : void +> : any +} diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.symbols b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.symbols new file mode 100644 index 00000000000..bbfafadc6bf --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es5.ts === +class C { +>C : Symbol(C, Decl(asyncArrowFunctionCapturesArguments_es5.ts, 0, 0)) + + method() { +>method : Symbol(C.method, Decl(asyncArrowFunctionCapturesArguments_es5.ts, 0, 9)) + + function other() {} +>other : Symbol(other, Decl(asyncArrowFunctionCapturesArguments_es5.ts, 1, 13)) + + var fn = async () => await other.apply(this, arguments); +>fn : Symbol(fn, Decl(asyncArrowFunctionCapturesArguments_es5.ts, 3, 9)) +>other.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) +>other : Symbol(other, Decl(asyncArrowFunctionCapturesArguments_es5.ts, 1, 13)) +>apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) +>this : Symbol(C, Decl(asyncArrowFunctionCapturesArguments_es5.ts, 0, 0)) +>arguments : Symbol(arguments) + } +} + diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.types b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.types new file mode 100644 index 00000000000..6eaff62c0bf --- /dev/null +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es5.types @@ -0,0 +1,23 @@ +=== tests/cases/conformance/async/es5/asyncArrowFunction/asyncArrowFunctionCapturesArguments_es5.ts === +class C { +>C : C + + method() { +>method : () => void + + function other() {} +>other : () => void + + var fn = async () => await other.apply(this, arguments); +>fn : () => Promise +>async () => await other.apply(this, arguments) : () => Promise +>await other.apply(this, arguments) : any +>other.apply(this, arguments) : any +>other.apply : (this: Function, thisArg: any, argArray?: any) => any +>other : () => void +>apply : (this: Function, thisArg: any, argArray?: any) => any +>this : this +>arguments : IArguments + } +} + diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es2017.symbols b/tests/baselines/reference/asyncAwaitIsolatedModules_es2017.symbols new file mode 100644 index 00000000000..d7b11474f28 --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es2017.symbols @@ -0,0 +1,111 @@ +=== tests/cases/conformance/async/es2017/asyncAwaitIsolatedModules_es2017.ts === +import { MyPromise } from "missing"; +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) + +declare var p: Promise; +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es2017.ts, 2, 11)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare var mp: MyPromise; +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es2017.ts, 3, 11)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) + +async function f0() { } +>f0 : Symbol(f0, Decl(asyncAwaitIsolatedModules_es2017.ts, 3, 34)) + +async function f1(): Promise { } +>f1 : Symbol(f1, Decl(asyncAwaitIsolatedModules_es2017.ts, 5, 23)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +async function f3(): MyPromise { } +>f3 : Symbol(f3, Decl(asyncAwaitIsolatedModules_es2017.ts, 6, 38)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) + +let f4 = async function() { } +>f4 : Symbol(f4, Decl(asyncAwaitIsolatedModules_es2017.ts, 9, 3)) + +let f5 = async function(): Promise { } +>f5 : Symbol(f5, Decl(asyncAwaitIsolatedModules_es2017.ts, 10, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +let f6 = async function(): MyPromise { } +>f6 : Symbol(f6, Decl(asyncAwaitIsolatedModules_es2017.ts, 11, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) + +let f7 = async () => { }; +>f7 : Symbol(f7, Decl(asyncAwaitIsolatedModules_es2017.ts, 13, 3)) + +let f8 = async (): Promise => { }; +>f8 : Symbol(f8, Decl(asyncAwaitIsolatedModules_es2017.ts, 14, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +let f9 = async (): MyPromise => { }; +>f9 : Symbol(f9, Decl(asyncAwaitIsolatedModules_es2017.ts, 15, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) + +let f10 = async () => p; +>f10 : Symbol(f10, Decl(asyncAwaitIsolatedModules_es2017.ts, 16, 3)) +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es2017.ts, 2, 11)) + +let f11 = async () => mp; +>f11 : Symbol(f11, Decl(asyncAwaitIsolatedModules_es2017.ts, 17, 3)) +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es2017.ts, 3, 11)) + +let f12 = async (): Promise => mp; +>f12 : Symbol(f12, Decl(asyncAwaitIsolatedModules_es2017.ts, 18, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es2017.ts, 3, 11)) + +let f13 = async (): MyPromise => p; +>f13 : Symbol(f13, Decl(asyncAwaitIsolatedModules_es2017.ts, 19, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es2017.ts, 2, 11)) + +let o = { +>o : Symbol(o, Decl(asyncAwaitIsolatedModules_es2017.ts, 21, 3)) + + async m1() { }, +>m1 : Symbol(m1, Decl(asyncAwaitIsolatedModules_es2017.ts, 21, 9)) + + async m2(): Promise { }, +>m2 : Symbol(m2, Decl(asyncAwaitIsolatedModules_es2017.ts, 22, 16)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + async m3(): MyPromise { } +>m3 : Symbol(m3, Decl(asyncAwaitIsolatedModules_es2017.ts, 23, 31)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) + +}; + +class C { +>C : Symbol(C, Decl(asyncAwaitIsolatedModules_es2017.ts, 25, 2)) + + async m1() { } +>m1 : Symbol(C.m1, Decl(asyncAwaitIsolatedModules_es2017.ts, 27, 9)) + + async m2(): Promise { } +>m2 : Symbol(C.m2, Decl(asyncAwaitIsolatedModules_es2017.ts, 28, 15)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + async m3(): MyPromise { } +>m3 : Symbol(C.m3, Decl(asyncAwaitIsolatedModules_es2017.ts, 29, 30)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) + + static async m4() { } +>m4 : Symbol(C.m4, Decl(asyncAwaitIsolatedModules_es2017.ts, 30, 32)) + + static async m5(): Promise { } +>m5 : Symbol(C.m5, Decl(asyncAwaitIsolatedModules_es2017.ts, 31, 22)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + static async m6(): MyPromise { } +>m6 : Symbol(C.m6, Decl(asyncAwaitIsolatedModules_es2017.ts, 32, 37)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es2017.ts, 0, 8)) +} + +module M { +>M : Symbol(M, Decl(asyncAwaitIsolatedModules_es2017.ts, 34, 1)) + + export async function f1() { } +>f1 : Symbol(f1, Decl(asyncAwaitIsolatedModules_es2017.ts, 36, 10)) +} diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es2017.types b/tests/baselines/reference/asyncAwaitIsolatedModules_es2017.types new file mode 100644 index 00000000000..b4619989757 --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es2017.types @@ -0,0 +1,122 @@ +=== tests/cases/conformance/async/es2017/asyncAwaitIsolatedModules_es2017.ts === +import { MyPromise } from "missing"; +>MyPromise : any + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare var mp: MyPromise; +>mp : any +>MyPromise : any + +async function f0() { } +>f0 : () => Promise + +async function f1(): Promise { } +>f1 : () => Promise +>Promise : Promise + +async function f3(): MyPromise { } +>f3 : () => any +>MyPromise : any + +let f4 = async function() { } +>f4 : () => Promise +>async function() { } : () => Promise + +let f5 = async function(): Promise { } +>f5 : () => Promise +>async function(): Promise { } : () => Promise +>Promise : Promise + +let f6 = async function(): MyPromise { } +>f6 : () => any +>async function(): MyPromise { } : () => any +>MyPromise : any + +let f7 = async () => { }; +>f7 : () => Promise +>async () => { } : () => Promise + +let f8 = async (): Promise => { }; +>f8 : () => Promise +>async (): Promise => { } : () => Promise +>Promise : Promise + +let f9 = async (): MyPromise => { }; +>f9 : () => any +>async (): MyPromise => { } : () => any +>MyPromise : any + +let f10 = async () => p; +>f10 : () => Promise +>async () => p : () => Promise +>p : Promise + +let f11 = async () => mp; +>f11 : () => Promise +>async () => mp : () => Promise +>mp : any + +let f12 = async (): Promise => mp; +>f12 : () => Promise +>async (): Promise => mp : () => Promise +>Promise : Promise +>mp : any + +let f13 = async (): MyPromise => p; +>f13 : () => any +>async (): MyPromise => p : () => any +>MyPromise : any +>p : Promise + +let o = { +>o : { m1(): Promise; m2(): Promise; m3(): any; } +>{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): any; } + + async m1() { }, +>m1 : () => Promise + + async m2(): Promise { }, +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => any +>MyPromise : any + +}; + +class C { +>C : C + + async m1() { } +>m1 : () => Promise + + async m2(): Promise { } +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => any +>MyPromise : any + + static async m4() { } +>m4 : () => Promise + + static async m5(): Promise { } +>m5 : () => Promise +>Promise : Promise + + static async m6(): MyPromise { } +>m6 : () => any +>MyPromise : any +} + +module M { +>M : typeof M + + export async function f1() { } +>f1 : () => Promise +} diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es5.symbols b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.symbols new file mode 100644 index 00000000000..eaa6042ee3d --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.symbols @@ -0,0 +1,111 @@ +=== tests/cases/conformance/async/es5/asyncAwaitIsolatedModules_es5.ts === +import { MyPromise } from "missing"; +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) + +declare var p: Promise; +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es5.ts, 2, 11)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + +declare var mp: MyPromise; +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es5.ts, 3, 11)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) + +async function f0() { } +>f0 : Symbol(f0, Decl(asyncAwaitIsolatedModules_es5.ts, 3, 34)) + +async function f1(): Promise { } +>f1 : Symbol(f1, Decl(asyncAwaitIsolatedModules_es5.ts, 5, 23)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + +async function f3(): MyPromise { } +>f3 : Symbol(f3, Decl(asyncAwaitIsolatedModules_es5.ts, 6, 38)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) + +let f4 = async function() { } +>f4 : Symbol(f4, Decl(asyncAwaitIsolatedModules_es5.ts, 9, 3)) + +let f5 = async function(): Promise { } +>f5 : Symbol(f5, Decl(asyncAwaitIsolatedModules_es5.ts, 10, 3)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + +let f6 = async function(): MyPromise { } +>f6 : Symbol(f6, Decl(asyncAwaitIsolatedModules_es5.ts, 11, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) + +let f7 = async () => { }; +>f7 : Symbol(f7, Decl(asyncAwaitIsolatedModules_es5.ts, 13, 3)) + +let f8 = async (): Promise => { }; +>f8 : Symbol(f8, Decl(asyncAwaitIsolatedModules_es5.ts, 14, 3)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + +let f9 = async (): MyPromise => { }; +>f9 : Symbol(f9, Decl(asyncAwaitIsolatedModules_es5.ts, 15, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) + +let f10 = async () => p; +>f10 : Symbol(f10, Decl(asyncAwaitIsolatedModules_es5.ts, 16, 3)) +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es5.ts, 2, 11)) + +let f11 = async () => mp; +>f11 : Symbol(f11, Decl(asyncAwaitIsolatedModules_es5.ts, 17, 3)) +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es5.ts, 3, 11)) + +let f12 = async (): Promise => mp; +>f12 : Symbol(f12, Decl(asyncAwaitIsolatedModules_es5.ts, 18, 3)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es5.ts, 3, 11)) + +let f13 = async (): MyPromise => p; +>f13 : Symbol(f13, Decl(asyncAwaitIsolatedModules_es5.ts, 19, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es5.ts, 2, 11)) + +let o = { +>o : Symbol(o, Decl(asyncAwaitIsolatedModules_es5.ts, 21, 3)) + + async m1() { }, +>m1 : Symbol(m1, Decl(asyncAwaitIsolatedModules_es5.ts, 21, 9)) + + async m2(): Promise { }, +>m2 : Symbol(m2, Decl(asyncAwaitIsolatedModules_es5.ts, 22, 16)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + async m3(): MyPromise { } +>m3 : Symbol(m3, Decl(asyncAwaitIsolatedModules_es5.ts, 23, 31)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) + +}; + +class C { +>C : Symbol(C, Decl(asyncAwaitIsolatedModules_es5.ts, 25, 2)) + + async m1() { } +>m1 : Symbol(C.m1, Decl(asyncAwaitIsolatedModules_es5.ts, 27, 9)) + + async m2(): Promise { } +>m2 : Symbol(C.m2, Decl(asyncAwaitIsolatedModules_es5.ts, 28, 15)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + async m3(): MyPromise { } +>m3 : Symbol(C.m3, Decl(asyncAwaitIsolatedModules_es5.ts, 29, 30)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) + + static async m4() { } +>m4 : Symbol(C.m4, Decl(asyncAwaitIsolatedModules_es5.ts, 30, 32)) + + static async m5(): Promise { } +>m5 : Symbol(C.m5, Decl(asyncAwaitIsolatedModules_es5.ts, 31, 22)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + static async m6(): MyPromise { } +>m6 : Symbol(C.m6, Decl(asyncAwaitIsolatedModules_es5.ts, 32, 37)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es5.ts, 0, 8)) +} + +module M { +>M : Symbol(M, Decl(asyncAwaitIsolatedModules_es5.ts, 34, 1)) + + export async function f1() { } +>f1 : Symbol(f1, Decl(asyncAwaitIsolatedModules_es5.ts, 36, 10)) +} diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es5.types b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.types new file mode 100644 index 00000000000..8630666ec62 --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.types @@ -0,0 +1,122 @@ +=== tests/cases/conformance/async/es5/asyncAwaitIsolatedModules_es5.ts === +import { MyPromise } from "missing"; +>MyPromise : any + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare var mp: MyPromise; +>mp : any +>MyPromise : any + +async function f0() { } +>f0 : () => Promise + +async function f1(): Promise { } +>f1 : () => Promise +>Promise : Promise + +async function f3(): MyPromise { } +>f3 : () => any +>MyPromise : any + +let f4 = async function() { } +>f4 : () => Promise +>async function() { } : () => Promise + +let f5 = async function(): Promise { } +>f5 : () => Promise +>async function(): Promise { } : () => Promise +>Promise : Promise + +let f6 = async function(): MyPromise { } +>f6 : () => any +>async function(): MyPromise { } : () => any +>MyPromise : any + +let f7 = async () => { }; +>f7 : () => Promise +>async () => { } : () => Promise + +let f8 = async (): Promise => { }; +>f8 : () => Promise +>async (): Promise => { } : () => Promise +>Promise : Promise + +let f9 = async (): MyPromise => { }; +>f9 : () => any +>async (): MyPromise => { } : () => any +>MyPromise : any + +let f10 = async () => p; +>f10 : () => Promise +>async () => p : () => Promise +>p : Promise + +let f11 = async () => mp; +>f11 : () => Promise +>async () => mp : () => Promise +>mp : any + +let f12 = async (): Promise => mp; +>f12 : () => Promise +>async (): Promise => mp : () => Promise +>Promise : Promise +>mp : any + +let f13 = async (): MyPromise => p; +>f13 : () => any +>async (): MyPromise => p : () => any +>MyPromise : any +>p : Promise + +let o = { +>o : { m1(): Promise; m2(): Promise; m3(): any; } +>{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): any; } + + async m1() { }, +>m1 : () => Promise + + async m2(): Promise { }, +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => any +>MyPromise : any + +}; + +class C { +>C : C + + async m1() { } +>m1 : () => Promise + + async m2(): Promise { } +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => any +>MyPromise : any + + static async m4() { } +>m4 : () => Promise + + static async m5(): Promise { } +>m5 : () => Promise +>Promise : Promise + + static async m6(): MyPromise { } +>m6 : () => any +>MyPromise : any +} + +module M { +>M : typeof M + + export async function f1() { } +>f1 : () => Promise +} diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols new file mode 100644 index 00000000000..2d1808b8b8b --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.symbols @@ -0,0 +1,111 @@ +=== tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts === +import { MyPromise } from "missing"; +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) + +declare var p: Promise; +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es6.ts, 2, 11)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +declare var mp: MyPromise; +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es6.ts, 3, 11)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) + +async function f0() { } +>f0 : Symbol(f0, Decl(asyncAwaitIsolatedModules_es6.ts, 3, 34)) + +async function f1(): Promise { } +>f1 : Symbol(f1, Decl(asyncAwaitIsolatedModules_es6.ts, 5, 23)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +async function f3(): MyPromise { } +>f3 : Symbol(f3, Decl(asyncAwaitIsolatedModules_es6.ts, 6, 38)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) + +let f4 = async function() { } +>f4 : Symbol(f4, Decl(asyncAwaitIsolatedModules_es6.ts, 9, 3)) + +let f5 = async function(): Promise { } +>f5 : Symbol(f5, Decl(asyncAwaitIsolatedModules_es6.ts, 10, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +let f6 = async function(): MyPromise { } +>f6 : Symbol(f6, Decl(asyncAwaitIsolatedModules_es6.ts, 11, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) + +let f7 = async () => { }; +>f7 : Symbol(f7, Decl(asyncAwaitIsolatedModules_es6.ts, 13, 3)) + +let f8 = async (): Promise => { }; +>f8 : Symbol(f8, Decl(asyncAwaitIsolatedModules_es6.ts, 14, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + +let f9 = async (): MyPromise => { }; +>f9 : Symbol(f9, Decl(asyncAwaitIsolatedModules_es6.ts, 15, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) + +let f10 = async () => p; +>f10 : Symbol(f10, Decl(asyncAwaitIsolatedModules_es6.ts, 16, 3)) +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es6.ts, 2, 11)) + +let f11 = async () => mp; +>f11 : Symbol(f11, Decl(asyncAwaitIsolatedModules_es6.ts, 17, 3)) +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es6.ts, 3, 11)) + +let f12 = async (): Promise => mp; +>f12 : Symbol(f12, Decl(asyncAwaitIsolatedModules_es6.ts, 18, 3)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>mp : Symbol(mp, Decl(asyncAwaitIsolatedModules_es6.ts, 3, 11)) + +let f13 = async (): MyPromise => p; +>f13 : Symbol(f13, Decl(asyncAwaitIsolatedModules_es6.ts, 19, 3)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) +>p : Symbol(p, Decl(asyncAwaitIsolatedModules_es6.ts, 2, 11)) + +let o = { +>o : Symbol(o, Decl(asyncAwaitIsolatedModules_es6.ts, 21, 3)) + + async m1() { }, +>m1 : Symbol(m1, Decl(asyncAwaitIsolatedModules_es6.ts, 21, 9)) + + async m2(): Promise { }, +>m2 : Symbol(m2, Decl(asyncAwaitIsolatedModules_es6.ts, 22, 16)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + async m3(): MyPromise { } +>m3 : Symbol(m3, Decl(asyncAwaitIsolatedModules_es6.ts, 23, 31)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) + +}; + +class C { +>C : Symbol(C, Decl(asyncAwaitIsolatedModules_es6.ts, 25, 2)) + + async m1() { } +>m1 : Symbol(C.m1, Decl(asyncAwaitIsolatedModules_es6.ts, 27, 9)) + + async m2(): Promise { } +>m2 : Symbol(C.m2, Decl(asyncAwaitIsolatedModules_es6.ts, 28, 15)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + async m3(): MyPromise { } +>m3 : Symbol(C.m3, Decl(asyncAwaitIsolatedModules_es6.ts, 29, 30)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) + + static async m4() { } +>m4 : Symbol(C.m4, Decl(asyncAwaitIsolatedModules_es6.ts, 30, 32)) + + static async m5(): Promise { } +>m5 : Symbol(C.m5, Decl(asyncAwaitIsolatedModules_es6.ts, 31, 22)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + static async m6(): MyPromise { } +>m6 : Symbol(C.m6, Decl(asyncAwaitIsolatedModules_es6.ts, 32, 37)) +>MyPromise : Symbol(MyPromise, Decl(asyncAwaitIsolatedModules_es6.ts, 0, 8)) +} + +module M { +>M : Symbol(M, Decl(asyncAwaitIsolatedModules_es6.ts, 34, 1)) + + export async function f1() { } +>f1 : Symbol(f1, Decl(asyncAwaitIsolatedModules_es6.ts, 36, 10)) +} diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.types b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.types new file mode 100644 index 00000000000..7c2d9d0fa0b --- /dev/null +++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.types @@ -0,0 +1,122 @@ +=== tests/cases/conformance/async/es6/asyncAwaitIsolatedModules_es6.ts === +import { MyPromise } from "missing"; +>MyPromise : any + +declare var p: Promise; +>p : Promise +>Promise : Promise + +declare var mp: MyPromise; +>mp : any +>MyPromise : any + +async function f0() { } +>f0 : () => Promise + +async function f1(): Promise { } +>f1 : () => Promise +>Promise : Promise + +async function f3(): MyPromise { } +>f3 : () => any +>MyPromise : any + +let f4 = async function() { } +>f4 : () => Promise +>async function() { } : () => Promise + +let f5 = async function(): Promise { } +>f5 : () => Promise +>async function(): Promise { } : () => Promise +>Promise : Promise + +let f6 = async function(): MyPromise { } +>f6 : () => any +>async function(): MyPromise { } : () => any +>MyPromise : any + +let f7 = async () => { }; +>f7 : () => Promise +>async () => { } : () => Promise + +let f8 = async (): Promise => { }; +>f8 : () => Promise +>async (): Promise => { } : () => Promise +>Promise : Promise + +let f9 = async (): MyPromise => { }; +>f9 : () => any +>async (): MyPromise => { } : () => any +>MyPromise : any + +let f10 = async () => p; +>f10 : () => Promise +>async () => p : () => Promise +>p : Promise + +let f11 = async () => mp; +>f11 : () => Promise +>async () => mp : () => Promise +>mp : any + +let f12 = async (): Promise => mp; +>f12 : () => Promise +>async (): Promise => mp : () => Promise +>Promise : Promise +>mp : any + +let f13 = async (): MyPromise => p; +>f13 : () => any +>async (): MyPromise => p : () => any +>MyPromise : any +>p : Promise + +let o = { +>o : { m1(): Promise; m2(): Promise; m3(): any; } +>{ async m1() { }, async m2(): Promise { }, async m3(): MyPromise { }} : { m1(): Promise; m2(): Promise; m3(): any; } + + async m1() { }, +>m1 : () => Promise + + async m2(): Promise { }, +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => any +>MyPromise : any + +}; + +class C { +>C : C + + async m1() { } +>m1 : () => Promise + + async m2(): Promise { } +>m2 : () => Promise +>Promise : Promise + + async m3(): MyPromise { } +>m3 : () => any +>MyPromise : any + + static async m4() { } +>m4 : () => Promise + + static async m5(): Promise { } +>m5 : () => Promise +>Promise : Promise + + static async m6(): MyPromise { } +>m6 : () => any +>MyPromise : any +} + +module M { +>M : typeof M + + export async function f1() { } +>f1 : () => Promise +} diff --git a/tests/baselines/reference/asyncClass_es5.symbols b/tests/baselines/reference/asyncClass_es5.symbols new file mode 100644 index 00000000000..f8f1ae8a067 --- /dev/null +++ b/tests/baselines/reference/asyncClass_es5.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es5/asyncClass_es5.ts === +async class C { +>C : Symbol(C, Decl(asyncClass_es5.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncClass_es5.types b/tests/baselines/reference/asyncClass_es5.types new file mode 100644 index 00000000000..9d3a2d1453b --- /dev/null +++ b/tests/baselines/reference/asyncClass_es5.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es5/asyncClass_es5.ts === +async class C { +>C : C +} diff --git a/tests/baselines/reference/asyncClass_es6.symbols b/tests/baselines/reference/asyncClass_es6.symbols new file mode 100644 index 00000000000..a268c0f8351 --- /dev/null +++ b/tests/baselines/reference/asyncClass_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/asyncClass_es6.ts === +async class C { +>C : Symbol(C, Decl(asyncClass_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncClass_es6.types b/tests/baselines/reference/asyncClass_es6.types new file mode 100644 index 00000000000..1136f3f8210 --- /dev/null +++ b/tests/baselines/reference/asyncClass_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/asyncClass_es6.ts === +async class C { +>C : C +} diff --git a/tests/baselines/reference/asyncConstructor_es5.symbols b/tests/baselines/reference/asyncConstructor_es5.symbols new file mode 100644 index 00000000000..3895d80e077 --- /dev/null +++ b/tests/baselines/reference/asyncConstructor_es5.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es5/asyncConstructor_es5.ts === +class C { +>C : Symbol(C, Decl(asyncConstructor_es5.ts, 0, 0)) + + async constructor() { + } +} diff --git a/tests/baselines/reference/asyncConstructor_es5.types b/tests/baselines/reference/asyncConstructor_es5.types new file mode 100644 index 00000000000..a7847ee6968 --- /dev/null +++ b/tests/baselines/reference/asyncConstructor_es5.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es5/asyncConstructor_es5.ts === +class C { +>C : C + + async constructor() { + } +} diff --git a/tests/baselines/reference/asyncConstructor_es6.symbols b/tests/baselines/reference/asyncConstructor_es6.symbols new file mode 100644 index 00000000000..82fdcf33e1e --- /dev/null +++ b/tests/baselines/reference/asyncConstructor_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/asyncConstructor_es6.ts === +class C { +>C : Symbol(C, Decl(asyncConstructor_es6.ts, 0, 0)) + + async constructor() { + } +} diff --git a/tests/baselines/reference/asyncConstructor_es6.types b/tests/baselines/reference/asyncConstructor_es6.types new file mode 100644 index 00000000000..cff36dbcb40 --- /dev/null +++ b/tests/baselines/reference/asyncConstructor_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/asyncConstructor_es6.ts === +class C { +>C : C + + async constructor() { + } +} diff --git a/tests/baselines/reference/asyncDeclare_es5.symbols b/tests/baselines/reference/asyncDeclare_es5.symbols new file mode 100644 index 00000000000..e839dc90e24 --- /dev/null +++ b/tests/baselines/reference/asyncDeclare_es5.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es5/asyncDeclare_es5.ts === +declare async function foo(): Promise; +>foo : Symbol(foo, Decl(asyncDeclare_es5.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + diff --git a/tests/baselines/reference/asyncDeclare_es5.types b/tests/baselines/reference/asyncDeclare_es5.types new file mode 100644 index 00000000000..91f034324eb --- /dev/null +++ b/tests/baselines/reference/asyncDeclare_es5.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es5/asyncDeclare_es5.ts === +declare async function foo(): Promise; +>foo : () => Promise +>Promise : Promise + diff --git a/tests/baselines/reference/asyncDeclare_es6.symbols b/tests/baselines/reference/asyncDeclare_es6.symbols new file mode 100644 index 00000000000..85ea6c9f905 --- /dev/null +++ b/tests/baselines/reference/asyncDeclare_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/asyncDeclare_es6.ts === +declare async function foo(): Promise; +>foo : Symbol(foo, Decl(asyncDeclare_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + diff --git a/tests/baselines/reference/asyncDeclare_es6.types b/tests/baselines/reference/asyncDeclare_es6.types new file mode 100644 index 00000000000..b4cb50157a3 --- /dev/null +++ b/tests/baselines/reference/asyncDeclare_es6.types @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/asyncDeclare_es6.ts === +declare async function foo(): Promise; +>foo : () => Promise +>Promise : Promise + diff --git a/tests/baselines/reference/asyncEnum_es5.symbols b/tests/baselines/reference/asyncEnum_es5.symbols new file mode 100644 index 00000000000..5fedc239a71 --- /dev/null +++ b/tests/baselines/reference/asyncEnum_es5.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es5/asyncEnum_es5.ts === +async enum E { +>E : Symbol(E, Decl(asyncEnum_es5.ts, 0, 0)) + + Value +>Value : Symbol(E.Value, Decl(asyncEnum_es5.ts, 0, 14)) +} diff --git a/tests/baselines/reference/asyncEnum_es5.types b/tests/baselines/reference/asyncEnum_es5.types new file mode 100644 index 00000000000..2f94fd33152 --- /dev/null +++ b/tests/baselines/reference/asyncEnum_es5.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es5/asyncEnum_es5.ts === +async enum E { +>E : E + + Value +>Value : E +} diff --git a/tests/baselines/reference/asyncEnum_es6.symbols b/tests/baselines/reference/asyncEnum_es6.symbols new file mode 100644 index 00000000000..ee5ef5df67b --- /dev/null +++ b/tests/baselines/reference/asyncEnum_es6.symbols @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/asyncEnum_es6.ts === +async enum E { +>E : Symbol(E, Decl(asyncEnum_es6.ts, 0, 0)) + + Value +>Value : Symbol(E.Value, Decl(asyncEnum_es6.ts, 0, 14)) +} diff --git a/tests/baselines/reference/asyncEnum_es6.types b/tests/baselines/reference/asyncEnum_es6.types new file mode 100644 index 00000000000..c28b646edf9 --- /dev/null +++ b/tests/baselines/reference/asyncEnum_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/asyncEnum_es6.ts === +async enum E { +>E : E + + Value +>Value : E +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.symbols new file mode 100644 index 00000000000..1079ab5c323 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts === +async function foo(a = await => await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration10_es2017.ts, 0, 0)) +>a : Symbol(a, Decl(asyncFunctionDeclaration10_es2017.ts, 0, 19)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.types new file mode 100644 index 00000000000..906a0966c0a --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es2017.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration10_es2017.ts === +async function foo(a = await => await): Promise { +>foo : (a?: any) => any +>a : any +>await : any +> : any +>await : any +>Promise {} : boolean +>PromisePromise : PromiseConstructor +>void : undefined +> : any +>{} : {} +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es5.symbols new file mode 100644 index 00000000000..1d9f9c590d8 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es5.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts === +async function foo(a = await => await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration10_es5.ts, 0, 0)) +>a : Symbol(a, Decl(asyncFunctionDeclaration10_es5.ts, 0, 19)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es5.types b/tests/baselines/reference/asyncFunctionDeclaration10_es5.types new file mode 100644 index 00000000000..70a16d0fc52 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es5.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration10_es5.ts === +async function foo(a = await => await): Promise { +>foo : (a?: any) => any +>a : any +>await : any +> : any +>await : any +>Promise {} : boolean +>PromisePromise : PromiseConstructor +>void : undefined +> : any +>{} : {} +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols new file mode 100644 index 00000000000..cbfb1bbf88d --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts === +async function foo(a = await => await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration10_es6.ts, 0, 0)) +>a : Symbol(a, Decl(asyncFunctionDeclaration10_es6.ts, 0, 19)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration10_es6.types b/tests/baselines/reference/asyncFunctionDeclaration10_es6.types new file mode 100644 index 00000000000..f5d5ae89afd --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration10_es6.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration10_es6.ts === +async function foo(a = await => await): Promise { +>foo : (a?: any) => any +>a : any +>await : any +> : any +>await : any +>Promise {} : boolean +>PromisePromise : PromiseConstructor +>void : undefined +> : any +>{} : {} +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration12_es2017.symbols new file mode 100644 index 00000000000..54cecdaf238 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es2017.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration12_es2017.ts === +var v = async function await(): Promise { } +>v : Symbol(v, Decl(asyncFunctionDeclaration12_es2017.ts, 0, 3)) +>await : Symbol(await, Decl(asyncFunctionDeclaration12_es2017.ts, 0, 22)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration12_es2017.types new file mode 100644 index 00000000000..1881a3cb4fd --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es2017.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration12_es2017.ts === +var v = async function await(): Promise { } +>v : () => any +>async function : () => any +>await : () => Promise +>(): Promise { } : () => Promise +>Promise : Promise + diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration12_es5.symbols new file mode 100644 index 00000000000..231dc33c20d --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es5.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration12_es5.ts === +var v = async function await(): Promise { } +>v : Symbol(v, Decl(asyncFunctionDeclaration12_es5.ts, 0, 3)) +>await : Symbol(await, Decl(asyncFunctionDeclaration12_es5.ts, 0, 22)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es5.types b/tests/baselines/reference/asyncFunctionDeclaration12_es5.types new file mode 100644 index 00000000000..242eca7c5a4 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es5.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration12_es5.ts === +var v = async function await(): Promise { } +>v : () => any +>async function : () => any +>await : () => Promise +>(): Promise { } : () => Promise +>Promise : Promise + diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols new file mode 100644 index 00000000000..f8adf060dc9 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts === +var v = async function await(): Promise { } +>v : Symbol(v, Decl(asyncFunctionDeclaration12_es6.ts, 0, 3)) +>await : Symbol(await, Decl(asyncFunctionDeclaration12_es6.ts, 0, 22)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.types b/tests/baselines/reference/asyncFunctionDeclaration12_es6.types new file mode 100644 index 00000000000..acf108d9761 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts === +var v = async function await(): Promise { } +>v : () => any +>async function : () => any +>await : () => Promise +>(): Promise { } : () => Promise +>Promise : Promise + diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration13_es2017.symbols new file mode 100644 index 00000000000..8ee3ca58938 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es2017.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration13_es2017.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration13_es2017.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // Legal to use 'await' in a type context. + var v: await; +>v : Symbol(v, Decl(asyncFunctionDeclaration13_es2017.ts, 2, 6)) +} + diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration13_es2017.types new file mode 100644 index 00000000000..c93c19da496 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es2017.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration13_es2017.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise + + // Legal to use 'await' in a type context. + var v: await; +>v : any +>await : No type information available! +} + diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration13_es5.symbols new file mode 100644 index 00000000000..e92467e5f41 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es5.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration13_es5.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration13_es5.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + // Legal to use 'await' in a type context. + var v: await; +>v : Symbol(v, Decl(asyncFunctionDeclaration13_es5.ts, 2, 6)) +} + diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es5.types b/tests/baselines/reference/asyncFunctionDeclaration13_es5.types new file mode 100644 index 00000000000..c8ec02c275d --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es5.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration13_es5.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise + + // Legal to use 'await' in a type context. + var v: await; +>v : any +>await : No type information available! +} + diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols new file mode 100644 index 00000000000..05d7c586cab --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration13_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // Legal to use 'await' in a type context. + var v: await; +>v : Symbol(v, Decl(asyncFunctionDeclaration13_es6.ts, 2, 6)) +} + diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.types b/tests/baselines/reference/asyncFunctionDeclaration13_es6.types new file mode 100644 index 00000000000..7e963caab85 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration13_es6.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise + + // Legal to use 'await' in a type context. + var v: await; +>v : any +>await : No type information available! +} + diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration15_es5.symbols new file mode 100644 index 00000000000..3bc9a18ca81 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es5.symbols @@ -0,0 +1,83 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts === +declare class Thenable { then(): void; } +>Thenable : Symbol(Thenable, Decl(asyncFunctionDeclaration15_es5.ts, 0, 0)) +>then : Symbol(Thenable.then, Decl(asyncFunctionDeclaration15_es5.ts, 0, 24)) + +declare let a: any; +>a : Symbol(a, Decl(asyncFunctionDeclaration15_es5.ts, 1, 11)) + +declare let obj: { then: string; }; +>obj : Symbol(obj, Decl(asyncFunctionDeclaration15_es5.ts, 2, 11)) +>then : Symbol(then, Decl(asyncFunctionDeclaration15_es5.ts, 2, 18)) + +declare let thenable: Thenable; +>thenable : Symbol(thenable, Decl(asyncFunctionDeclaration15_es5.ts, 3, 11)) +>Thenable : Symbol(Thenable, Decl(asyncFunctionDeclaration15_es5.ts, 0, 0)) + +async function fn1() { } // valid: Promise +>fn1 : Symbol(fn1, Decl(asyncFunctionDeclaration15_es5.ts, 3, 31)) + +async function fn2(): { } { } // error +>fn2 : Symbol(fn2, Decl(asyncFunctionDeclaration15_es5.ts, 4, 24)) + +async function fn3(): any { } // error +>fn3 : Symbol(fn3, Decl(asyncFunctionDeclaration15_es5.ts, 5, 29)) + +async function fn4(): number { } // error +>fn4 : Symbol(fn4, Decl(asyncFunctionDeclaration15_es5.ts, 6, 29)) + +async function fn5(): PromiseLike { } // error +>fn5 : Symbol(fn5, Decl(asyncFunctionDeclaration15_es5.ts, 7, 32)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) + +async function fn6(): Thenable { } // error +>fn6 : Symbol(fn6, Decl(asyncFunctionDeclaration15_es5.ts, 8, 43)) +>Thenable : Symbol(Thenable, Decl(asyncFunctionDeclaration15_es5.ts, 0, 0)) + +async function fn7() { return; } // valid: Promise +>fn7 : Symbol(fn7, Decl(asyncFunctionDeclaration15_es5.ts, 9, 34)) + +async function fn8() { return 1; } // valid: Promise +>fn8 : Symbol(fn8, Decl(asyncFunctionDeclaration15_es5.ts, 10, 32)) + +async function fn9() { return null; } // valid: Promise +>fn9 : Symbol(fn9, Decl(asyncFunctionDeclaration15_es5.ts, 11, 34)) + +async function fn10() { return undefined; } // valid: Promise +>fn10 : Symbol(fn10, Decl(asyncFunctionDeclaration15_es5.ts, 12, 37)) +>undefined : Symbol(undefined) + +async function fn11() { return a; } // valid: Promise +>fn11 : Symbol(fn11, Decl(asyncFunctionDeclaration15_es5.ts, 13, 43)) +>a : Symbol(a, Decl(asyncFunctionDeclaration15_es5.ts, 1, 11)) + +async function fn12() { return obj; } // valid: Promise<{ then: string; }> +>fn12 : Symbol(fn12, Decl(asyncFunctionDeclaration15_es5.ts, 14, 35)) +>obj : Symbol(obj, Decl(asyncFunctionDeclaration15_es5.ts, 2, 11)) + +async function fn13() { return thenable; } // error +>fn13 : Symbol(fn13, Decl(asyncFunctionDeclaration15_es5.ts, 15, 37)) +>thenable : Symbol(thenable, Decl(asyncFunctionDeclaration15_es5.ts, 3, 11)) + +async function fn14() { await 1; } // valid: Promise +>fn14 : Symbol(fn14, Decl(asyncFunctionDeclaration15_es5.ts, 16, 42)) + +async function fn15() { await null; } // valid: Promise +>fn15 : Symbol(fn15, Decl(asyncFunctionDeclaration15_es5.ts, 17, 34)) + +async function fn16() { await undefined; } // valid: Promise +>fn16 : Symbol(fn16, Decl(asyncFunctionDeclaration15_es5.ts, 18, 37)) +>undefined : Symbol(undefined) + +async function fn17() { await a; } // valid: Promise +>fn17 : Symbol(fn17, Decl(asyncFunctionDeclaration15_es5.ts, 19, 42)) +>a : Symbol(a, Decl(asyncFunctionDeclaration15_es5.ts, 1, 11)) + +async function fn18() { await obj; } // valid: Promise +>fn18 : Symbol(fn18, Decl(asyncFunctionDeclaration15_es5.ts, 20, 34)) +>obj : Symbol(obj, Decl(asyncFunctionDeclaration15_es5.ts, 2, 11)) + +async function fn19() { await thenable; } // error +>fn19 : Symbol(fn19, Decl(asyncFunctionDeclaration15_es5.ts, 21, 36)) +>thenable : Symbol(thenable, Decl(asyncFunctionDeclaration15_es5.ts, 3, 11)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es5.types b/tests/baselines/reference/asyncFunctionDeclaration15_es5.types new file mode 100644 index 00000000000..5ed68d1ab24 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es5.types @@ -0,0 +1,93 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts === +declare class Thenable { then(): void; } +>Thenable : Thenable +>then : () => void + +declare let a: any; +>a : any + +declare let obj: { then: string; }; +>obj : { then: string; } +>then : string + +declare let thenable: Thenable; +>thenable : Thenable +>Thenable : Thenable + +async function fn1() { } // valid: Promise +>fn1 : () => Promise + +async function fn2(): { } { } // error +>fn2 : () => {} + +async function fn3(): any { } // error +>fn3 : () => any + +async function fn4(): number { } // error +>fn4 : () => number + +async function fn5(): PromiseLike { } // error +>fn5 : () => PromiseLike +>PromiseLike : PromiseLike + +async function fn6(): Thenable { } // error +>fn6 : () => Thenable +>Thenable : Thenable + +async function fn7() { return; } // valid: Promise +>fn7 : () => Promise + +async function fn8() { return 1; } // valid: Promise +>fn8 : () => Promise +>1 : 1 + +async function fn9() { return null; } // valid: Promise +>fn9 : () => Promise +>null : null + +async function fn10() { return undefined; } // valid: Promise +>fn10 : () => Promise +>undefined : undefined + +async function fn11() { return a; } // valid: Promise +>fn11 : () => Promise +>a : any + +async function fn12() { return obj; } // valid: Promise<{ then: string; }> +>fn12 : () => Promise<{ then: string; }> +>obj : { then: string; } + +async function fn13() { return thenable; } // error +>fn13 : () => Promise +>thenable : Thenable + +async function fn14() { await 1; } // valid: Promise +>fn14 : () => Promise +>await 1 : 1 +>1 : 1 + +async function fn15() { await null; } // valid: Promise +>fn15 : () => Promise +>await null : null +>null : null + +async function fn16() { await undefined; } // valid: Promise +>fn16 : () => Promise +>await undefined : undefined +>undefined : undefined + +async function fn17() { await a; } // valid: Promise +>fn17 : () => Promise +>await a : any +>a : any + +async function fn18() { await obj; } // valid: Promise +>fn18 : () => Promise +>await obj : { then: string; } +>obj : { then: string; } + +async function fn19() { await thenable; } // error +>fn19 : () => Promise +>await thenable : any +>thenable : Thenable + diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols new file mode 100644 index 00000000000..daf0d23a7e8 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.symbols @@ -0,0 +1,83 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts === +declare class Thenable { then(): void; } +>Thenable : Symbol(Thenable, Decl(asyncFunctionDeclaration15_es6.ts, 0, 0)) +>then : Symbol(Thenable.then, Decl(asyncFunctionDeclaration15_es6.ts, 0, 24)) + +declare let a: any; +>a : Symbol(a, Decl(asyncFunctionDeclaration15_es6.ts, 1, 11)) + +declare let obj: { then: string; }; +>obj : Symbol(obj, Decl(asyncFunctionDeclaration15_es6.ts, 2, 11)) +>then : Symbol(then, Decl(asyncFunctionDeclaration15_es6.ts, 2, 18)) + +declare let thenable: Thenable; +>thenable : Symbol(thenable, Decl(asyncFunctionDeclaration15_es6.ts, 3, 11)) +>Thenable : Symbol(Thenable, Decl(asyncFunctionDeclaration15_es6.ts, 0, 0)) + +async function fn1() { } // valid: Promise +>fn1 : Symbol(fn1, Decl(asyncFunctionDeclaration15_es6.ts, 3, 31)) + +async function fn2(): { } { } // error +>fn2 : Symbol(fn2, Decl(asyncFunctionDeclaration15_es6.ts, 4, 24)) + +async function fn3(): any { } // error +>fn3 : Symbol(fn3, Decl(asyncFunctionDeclaration15_es6.ts, 5, 29)) + +async function fn4(): number { } // error +>fn4 : Symbol(fn4, Decl(asyncFunctionDeclaration15_es6.ts, 6, 29)) + +async function fn5(): PromiseLike { } // error +>fn5 : Symbol(fn5, Decl(asyncFunctionDeclaration15_es6.ts, 7, 32)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.es5.d.ts, --, --)) + +async function fn6(): Thenable { } // error +>fn6 : Symbol(fn6, Decl(asyncFunctionDeclaration15_es6.ts, 8, 43)) +>Thenable : Symbol(Thenable, Decl(asyncFunctionDeclaration15_es6.ts, 0, 0)) + +async function fn7() { return; } // valid: Promise +>fn7 : Symbol(fn7, Decl(asyncFunctionDeclaration15_es6.ts, 9, 34)) + +async function fn8() { return 1; } // valid: Promise +>fn8 : Symbol(fn8, Decl(asyncFunctionDeclaration15_es6.ts, 10, 32)) + +async function fn9() { return null; } // valid: Promise +>fn9 : Symbol(fn9, Decl(asyncFunctionDeclaration15_es6.ts, 11, 34)) + +async function fn10() { return undefined; } // valid: Promise +>fn10 : Symbol(fn10, Decl(asyncFunctionDeclaration15_es6.ts, 12, 37)) +>undefined : Symbol(undefined) + +async function fn11() { return a; } // valid: Promise +>fn11 : Symbol(fn11, Decl(asyncFunctionDeclaration15_es6.ts, 13, 43)) +>a : Symbol(a, Decl(asyncFunctionDeclaration15_es6.ts, 1, 11)) + +async function fn12() { return obj; } // valid: Promise<{ then: string; }> +>fn12 : Symbol(fn12, Decl(asyncFunctionDeclaration15_es6.ts, 14, 35)) +>obj : Symbol(obj, Decl(asyncFunctionDeclaration15_es6.ts, 2, 11)) + +async function fn13() { return thenable; } // error +>fn13 : Symbol(fn13, Decl(asyncFunctionDeclaration15_es6.ts, 15, 37)) +>thenable : Symbol(thenable, Decl(asyncFunctionDeclaration15_es6.ts, 3, 11)) + +async function fn14() { await 1; } // valid: Promise +>fn14 : Symbol(fn14, Decl(asyncFunctionDeclaration15_es6.ts, 16, 42)) + +async function fn15() { await null; } // valid: Promise +>fn15 : Symbol(fn15, Decl(asyncFunctionDeclaration15_es6.ts, 17, 34)) + +async function fn16() { await undefined; } // valid: Promise +>fn16 : Symbol(fn16, Decl(asyncFunctionDeclaration15_es6.ts, 18, 37)) +>undefined : Symbol(undefined) + +async function fn17() { await a; } // valid: Promise +>fn17 : Symbol(fn17, Decl(asyncFunctionDeclaration15_es6.ts, 19, 42)) +>a : Symbol(a, Decl(asyncFunctionDeclaration15_es6.ts, 1, 11)) + +async function fn18() { await obj; } // valid: Promise +>fn18 : Symbol(fn18, Decl(asyncFunctionDeclaration15_es6.ts, 20, 34)) +>obj : Symbol(obj, Decl(asyncFunctionDeclaration15_es6.ts, 2, 11)) + +async function fn19() { await thenable; } // error +>fn19 : Symbol(fn19, Decl(asyncFunctionDeclaration15_es6.ts, 21, 36)) +>thenable : Symbol(thenable, Decl(asyncFunctionDeclaration15_es6.ts, 3, 11)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.types b/tests/baselines/reference/asyncFunctionDeclaration15_es6.types new file mode 100644 index 00000000000..b3b176cc812 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.types @@ -0,0 +1,93 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts === +declare class Thenable { then(): void; } +>Thenable : Thenable +>then : () => void + +declare let a: any; +>a : any + +declare let obj: { then: string; }; +>obj : { then: string; } +>then : string + +declare let thenable: Thenable; +>thenable : Thenable +>Thenable : Thenable + +async function fn1() { } // valid: Promise +>fn1 : () => Promise + +async function fn2(): { } { } // error +>fn2 : () => {} + +async function fn3(): any { } // error +>fn3 : () => any + +async function fn4(): number { } // error +>fn4 : () => number + +async function fn5(): PromiseLike { } // error +>fn5 : () => PromiseLike +>PromiseLike : PromiseLike + +async function fn6(): Thenable { } // error +>fn6 : () => Thenable +>Thenable : Thenable + +async function fn7() { return; } // valid: Promise +>fn7 : () => Promise + +async function fn8() { return 1; } // valid: Promise +>fn8 : () => Promise +>1 : 1 + +async function fn9() { return null; } // valid: Promise +>fn9 : () => Promise +>null : null + +async function fn10() { return undefined; } // valid: Promise +>fn10 : () => Promise +>undefined : undefined + +async function fn11() { return a; } // valid: Promise +>fn11 : () => Promise +>a : any + +async function fn12() { return obj; } // valid: Promise<{ then: string; }> +>fn12 : () => Promise<{ then: string; }> +>obj : { then: string; } + +async function fn13() { return thenable; } // error +>fn13 : () => Promise +>thenable : Thenable + +async function fn14() { await 1; } // valid: Promise +>fn14 : () => Promise +>await 1 : 1 +>1 : 1 + +async function fn15() { await null; } // valid: Promise +>fn15 : () => Promise +>await null : null +>null : null + +async function fn16() { await undefined; } // valid: Promise +>fn16 : () => Promise +>await undefined : undefined +>undefined : undefined + +async function fn17() { await a; } // valid: Promise +>fn17 : () => Promise +>await a : any +>a : any + +async function fn18() { await obj; } // valid: Promise +>fn18 : () => Promise +>await obj : { then: string; } +>obj : { then: string; } + +async function fn19() { await thenable; } // error +>fn19 : () => Promise +>await thenable : any +>thenable : Thenable + diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration3_es2017.symbols new file mode 100644 index 00000000000..b444d4e17f1 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es2017.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration3_es2017.ts === +function f(await = await) { +>f : Symbol(f, Decl(asyncFunctionDeclaration3_es2017.ts, 0, 0)) +>await : Symbol(await, Decl(asyncFunctionDeclaration3_es2017.ts, 0, 11)) +>await : Symbol(await, Decl(asyncFunctionDeclaration3_es2017.ts, 0, 11)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration3_es2017.types new file mode 100644 index 00000000000..c7c56f7bfa1 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es2017.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration3_es2017.ts === +function f(await = await) { +>f : (await?: any) => void +>await : any +>await : any +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration3_es5.symbols new file mode 100644 index 00000000000..379fe683815 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es5.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration3_es5.ts === +function f(await = await) { +>f : Symbol(f, Decl(asyncFunctionDeclaration3_es5.ts, 0, 0)) +>await : Symbol(await, Decl(asyncFunctionDeclaration3_es5.ts, 0, 11)) +>await : Symbol(await, Decl(asyncFunctionDeclaration3_es5.ts, 0, 11)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es5.types b/tests/baselines/reference/asyncFunctionDeclaration3_es5.types new file mode 100644 index 00000000000..cec4e59ad86 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es5.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration3_es5.ts === +function f(await = await) { +>f : (await?: any) => void +>await : any +>await : any +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration3_es6.symbols new file mode 100644 index 00000000000..b869e6d7b62 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts === +function f(await = await) { +>f : Symbol(f, Decl(asyncFunctionDeclaration3_es6.ts, 0, 0)) +>await : Symbol(await, Decl(asyncFunctionDeclaration3_es6.ts, 0, 11)) +>await : Symbol(await, Decl(asyncFunctionDeclaration3_es6.ts, 0, 11)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration3_es6.types b/tests/baselines/reference/asyncFunctionDeclaration3_es6.types new file mode 100644 index 00000000000..12677cbe27a --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration3_es6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration3_es6.ts === +function f(await = await) { +>f : (await?: any) => void +>await : any +>await : any +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration5_es2017.symbols new file mode 100644 index 00000000000..8b501d4b03f --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es2017.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts === +async function foo(await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration5_es2017.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration5_es2017.types new file mode 100644 index 00000000000..fb19a3f5b11 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es2017.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration5_es2017.ts === +async function foo(await): Promise { +>foo : () => any +>await : any +>Promise {} : boolean +>PromisePromise : PromiseConstructor +>void : undefined +> : any +>{} : {} +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration5_es5.symbols new file mode 100644 index 00000000000..1bbc0b3650e --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es5.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts === +async function foo(await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration5_es5.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es5.types b/tests/baselines/reference/asyncFunctionDeclaration5_es5.types new file mode 100644 index 00000000000..c1a99312825 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es5.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration5_es5.ts === +async function foo(await): Promise { +>foo : () => any +>await : any +>Promise {} : boolean +>PromisePromise : PromiseConstructor +>void : undefined +> : any +>{} : {} +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols new file mode 100644 index 00000000000..61f040d2834 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts === +async function foo(await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration5_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration5_es6.types b/tests/baselines/reference/asyncFunctionDeclaration5_es6.types new file mode 100644 index 00000000000..30497fd457a --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration5_es6.types @@ -0,0 +1,11 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration5_es6.ts === +async function foo(await): Promise { +>foo : () => any +>await : any +>Promise {} : boolean +>PromisePromise : PromiseConstructor +>void : undefined +> : any +>{} : {} +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration6_es2017.symbols new file mode 100644 index 00000000000..7bac561d1e7 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es2017.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration6_es2017.ts === +async function foo(a = await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration6_es2017.ts, 0, 0)) +>a : Symbol(a, Decl(asyncFunctionDeclaration6_es2017.ts, 0, 19)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration6_es2017.types new file mode 100644 index 00000000000..5a1b84feae4 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es2017.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration6_es2017.ts === +async function foo(a = await): Promise { +>foo : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration6_es5.symbols new file mode 100644 index 00000000000..8e2533e8cdd --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es5.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration6_es5.ts === +async function foo(a = await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration6_es5.ts, 0, 0)) +>a : Symbol(a, Decl(asyncFunctionDeclaration6_es5.ts, 0, 19)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es5.types b/tests/baselines/reference/asyncFunctionDeclaration6_es5.types new file mode 100644 index 00000000000..02dd3d4be49 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es5.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration6_es5.ts === +async function foo(a = await): Promise { +>foo : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols new file mode 100644 index 00000000000..e9e5f97ee0e --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts === +async function foo(a = await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration6_es6.ts, 0, 0)) +>a : Symbol(a, Decl(asyncFunctionDeclaration6_es6.ts, 0, 19)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.types b/tests/baselines/reference/asyncFunctionDeclaration6_es6.types new file mode 100644 index 00000000000..b65c4ef61d3 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration6_es6.ts === +async function foo(a = await): Promise { +>foo : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration7_es2017.symbols new file mode 100644 index 00000000000..1fccc5a1c15 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es2017.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration7_es2017.ts === +async function bar(): Promise { +>bar : Symbol(bar, Decl(asyncFunctionDeclaration7_es2017.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration7_es2017.ts, 0, 37)) +>a : Symbol(a, Decl(asyncFunctionDeclaration7_es2017.ts, 2, 21)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + } +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration7_es2017.types new file mode 100644 index 00000000000..1d25294f229 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es2017.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration7_es2017.ts === +async function bar(): Promise { +>bar : () => Promise +>Promise : Promise + + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { +>foo : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise + } +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration7_es5.symbols new file mode 100644 index 00000000000..003cc2983e5 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es5.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration7_es5.ts === +async function bar(): Promise { +>bar : Symbol(bar, Decl(asyncFunctionDeclaration7_es5.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration7_es5.ts, 0, 37)) +>a : Symbol(a, Decl(asyncFunctionDeclaration7_es5.ts, 2, 21)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es5.types b/tests/baselines/reference/asyncFunctionDeclaration7_es5.types new file mode 100644 index 00000000000..f3bc39f8019 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es5.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration7_es5.ts === +async function bar(): Promise { +>bar : () => Promise +>Promise : Promise + + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { +>foo : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise + } +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols new file mode 100644 index 00000000000..67b117d59f8 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts === +async function bar(): Promise { +>bar : Symbol(bar, Decl(asyncFunctionDeclaration7_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration7_es6.ts, 0, 37)) +>a : Symbol(a, Decl(asyncFunctionDeclaration7_es6.ts, 2, 21)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + } +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.types b/tests/baselines/reference/asyncFunctionDeclaration7_es6.types new file mode 100644 index 00000000000..8a55a2377e2 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration7_es6.ts === +async function bar(): Promise { +>bar : () => Promise +>Promise : Promise + + // 'await' here is an identifier, and not a yield expression. + async function foo(a = await): Promise { +>foo : (a?: any) => Promise +>a : any +>await : any +> : any +>Promise : Promise + } +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration8_es2017.symbols new file mode 100644 index 00000000000..07e6d321196 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es2017.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration8_es2017.ts === +var v = { [await]: foo } +>v : Symbol(v, Decl(asyncFunctionDeclaration8_es2017.ts, 0, 3)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration8_es2017.types new file mode 100644 index 00000000000..9f28312a392 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es2017.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration8_es2017.ts === +var v = { [await]: foo } +>v : { [x: number]: any; } +>{ [await]: foo } : { [x: number]: any; } +>await : any +>foo : any + diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration8_es5.symbols new file mode 100644 index 00000000000..f30fa4f94d0 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es5.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration8_es5.ts === +var v = { [await]: foo } +>v : Symbol(v, Decl(asyncFunctionDeclaration8_es5.ts, 0, 3)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es5.types b/tests/baselines/reference/asyncFunctionDeclaration8_es5.types new file mode 100644 index 00000000000..d9073611a37 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es5.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration8_es5.ts === +var v = { [await]: foo } +>v : { [x: number]: any; } +>{ [await]: foo } : { [x: number]: any; } +>await : any +>foo : any + diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration8_es6.symbols new file mode 100644 index 00000000000..6c5218b27a6 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts === +var v = { [await]: foo } +>v : Symbol(v, Decl(asyncFunctionDeclaration8_es6.ts, 0, 3)) + diff --git a/tests/baselines/reference/asyncFunctionDeclaration8_es6.types b/tests/baselines/reference/asyncFunctionDeclaration8_es6.types new file mode 100644 index 00000000000..cb5929810e0 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration8_es6.types @@ -0,0 +1,7 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration8_es6.ts === +var v = { [await]: foo } +>v : { [x: number]: any; } +>{ [await]: foo } : { [x: number]: any; } +>await : any +>foo : any + diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration9_es2017.symbols new file mode 100644 index 00000000000..a11944c1d4c --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es2017.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration9_es2017.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration9_es2017.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + var v = { [await]: foo } +>v : Symbol(v, Decl(asyncFunctionDeclaration9_es2017.ts, 1, 5)) +>foo : Symbol(foo, Decl(asyncFunctionDeclaration9_es2017.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es2017.types b/tests/baselines/reference/asyncFunctionDeclaration9_es2017.types new file mode 100644 index 00000000000..c54a75b49ff --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es2017.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration9_es2017.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise + + var v = { [await]: foo } +>v : { [x: number]: () => Promise; } +>{ [await]: foo } : { [x: number]: () => Promise; } +>await : any +> : any +>foo : () => Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration9_es5.symbols new file mode 100644 index 00000000000..881371f8347 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es5.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration9_es5.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration9_es5.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + + var v = { [await]: foo } +>v : Symbol(v, Decl(asyncFunctionDeclaration9_es5.ts, 1, 5)) +>foo : Symbol(foo, Decl(asyncFunctionDeclaration9_es5.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es5.types b/tests/baselines/reference/asyncFunctionDeclaration9_es5.types new file mode 100644 index 00000000000..ca8382e57b1 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es5.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration9_es5.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise + + var v = { [await]: foo } +>v : { [x: number]: () => Promise; } +>{ [await]: foo } : { [x: number]: () => Promise; } +>await : any +> : any +>foo : () => Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols new file mode 100644 index 00000000000..9d46d6f6d8f --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts === +async function foo(): Promise { +>foo : Symbol(foo, Decl(asyncFunctionDeclaration9_es6.ts, 0, 0)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) + + var v = { [await]: foo } +>v : Symbol(v, Decl(asyncFunctionDeclaration9_es6.ts, 1, 5)) +>foo : Symbol(foo, Decl(asyncFunctionDeclaration9_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.types b/tests/baselines/reference/asyncFunctionDeclaration9_es6.types new file mode 100644 index 00000000000..4bdf4582509 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration9_es6.ts === +async function foo(): Promise { +>foo : () => Promise +>Promise : Promise + + var v = { [await]: foo } +>v : { [x: number]: () => Promise; } +>{ [await]: foo } : { [x: number]: () => Promise; } +>await : any +> : any +>foo : () => Promise +} diff --git a/tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.symbols b/tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.symbols new file mode 100644 index 00000000000..39aed2be1fe --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.symbols @@ -0,0 +1,22 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclarationCapturesArguments_es5.ts === +class C { +>C : Symbol(C, Decl(asyncFunctionDeclarationCapturesArguments_es5.ts, 0, 0)) + + method() { +>method : Symbol(C.method, Decl(asyncFunctionDeclarationCapturesArguments_es5.ts, 0, 9)) + + function other() {} +>other : Symbol(other, Decl(asyncFunctionDeclarationCapturesArguments_es5.ts, 1, 13)) + + async function fn () { +>fn : Symbol(fn, Decl(asyncFunctionDeclarationCapturesArguments_es5.ts, 2, 25)) + + await other.apply(this, arguments); +>other.apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) +>other : Symbol(other, Decl(asyncFunctionDeclarationCapturesArguments_es5.ts, 1, 13)) +>apply : Symbol(Function.apply, Decl(lib.es5.d.ts, --, --)) +>arguments : Symbol(arguments) + } + } +} + diff --git a/tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.types b/tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.types new file mode 100644 index 00000000000..a93094991df --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclarationCapturesArguments_es5.types @@ -0,0 +1,25 @@ +=== tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclarationCapturesArguments_es5.ts === +class C { +>C : C + + method() { +>method : () => void + + function other() {} +>other : () => void + + async function fn () { +>fn : () => Promise + + await other.apply(this, arguments); +>await other.apply(this, arguments) : any +>other.apply(this, arguments) : any +>other.apply : (this: Function, thisArg: any, argArray?: any) => any +>other : () => void +>apply : (this: Function, thisArg: any, argArray?: any) => any +>this : any +>arguments : IArguments + } + } +} + diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.symbols b/tests/baselines/reference/asyncFunctionNoReturnType.symbols new file mode 100644 index 00000000000..da7167599c9 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionNoReturnType.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/asyncFunctionNoReturnType.ts === +async () => { +No type information for this code. if (window) +No type information for this code. return; +No type information for this code.} +No type information for this code. +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.types b/tests/baselines/reference/asyncFunctionNoReturnType.types new file mode 100644 index 00000000000..48f8b33c39d --- /dev/null +++ b/tests/baselines/reference/asyncFunctionNoReturnType.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/asyncFunctionNoReturnType.ts === +async () => { +>async () => { if (window) return;} : () => Promise + + if (window) +>window : any + + return; +} + diff --git a/tests/baselines/reference/asyncGetter_es5.symbols b/tests/baselines/reference/asyncGetter_es5.symbols new file mode 100644 index 00000000000..c29c2e8dd3c --- /dev/null +++ b/tests/baselines/reference/asyncGetter_es5.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es5/asyncGetter_es5.ts === +class C { +>C : Symbol(C, Decl(asyncGetter_es5.ts, 0, 0)) + + async get foo() { +>foo : Symbol(C.foo, Decl(asyncGetter_es5.ts, 0, 9)) + } +} diff --git a/tests/baselines/reference/asyncGetter_es5.types b/tests/baselines/reference/asyncGetter_es5.types new file mode 100644 index 00000000000..071de68c9d7 --- /dev/null +++ b/tests/baselines/reference/asyncGetter_es5.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es5/asyncGetter_es5.ts === +class C { +>C : C + + async get foo() { +>foo : void + } +} diff --git a/tests/baselines/reference/asyncGetter_es6.symbols b/tests/baselines/reference/asyncGetter_es6.symbols new file mode 100644 index 00000000000..ee96c939468 --- /dev/null +++ b/tests/baselines/reference/asyncGetter_es6.symbols @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es6/asyncGetter_es6.ts === +class C { +>C : Symbol(C, Decl(asyncGetter_es6.ts, 0, 0)) + + async get foo() { +>foo : Symbol(C.foo, Decl(asyncGetter_es6.ts, 0, 9)) + } +} diff --git a/tests/baselines/reference/asyncGetter_es6.types b/tests/baselines/reference/asyncGetter_es6.types new file mode 100644 index 00000000000..e71c16c4a8b --- /dev/null +++ b/tests/baselines/reference/asyncGetter_es6.types @@ -0,0 +1,8 @@ +=== tests/cases/conformance/async/es6/asyncGetter_es6.ts === +class C { +>C : C + + async get foo() { +>foo : void + } +} diff --git a/tests/baselines/reference/asyncImportedPromise_es6.symbols b/tests/baselines/reference/asyncImportedPromise_es6.symbols new file mode 100644 index 00000000000..86f037946e2 --- /dev/null +++ b/tests/baselines/reference/asyncImportedPromise_es6.symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/async/es6/task.ts === +export class Task extends Promise { } +>Task : Symbol(Task, Decl(task.ts, 0, 0)) +>T : Symbol(T, Decl(task.ts, 0, 18)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>T : Symbol(T, Decl(task.ts, 0, 18)) + +=== tests/cases/conformance/async/es6/test.ts === +import { Task } from "./task"; +>Task : Symbol(Task, Decl(test.ts, 0, 8)) + +class Test { +>Test : Symbol(Test, Decl(test.ts, 0, 30)) + + async example(): Task { return; } +>example : Symbol(Test.example, Decl(test.ts, 1, 12)) +>T : Symbol(T, Decl(test.ts, 2, 18)) +>Task : Symbol(Task, Decl(test.ts, 0, 8)) +>T : Symbol(T, Decl(test.ts, 2, 18)) +} diff --git a/tests/baselines/reference/asyncImportedPromise_es6.types b/tests/baselines/reference/asyncImportedPromise_es6.types new file mode 100644 index 00000000000..424f14b34d3 --- /dev/null +++ b/tests/baselines/reference/asyncImportedPromise_es6.types @@ -0,0 +1,20 @@ +=== tests/cases/conformance/async/es6/task.ts === +export class Task extends Promise { } +>Task : Task +>T : T +>Promise : Promise +>T : T + +=== tests/cases/conformance/async/es6/test.ts === +import { Task } from "./task"; +>Task : typeof Task + +class Test { +>Test : Test + + async example(): Task { return; } +>example : () => Task +>T : T +>Task : Task +>T : T +} diff --git a/tests/baselines/reference/asyncInterface_es5.symbols b/tests/baselines/reference/asyncInterface_es5.symbols new file mode 100644 index 00000000000..d12228581dc --- /dev/null +++ b/tests/baselines/reference/asyncInterface_es5.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es5/asyncInterface_es5.ts === +async interface I { +>I : Symbol(I, Decl(asyncInterface_es5.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncInterface_es5.types b/tests/baselines/reference/asyncInterface_es5.types new file mode 100644 index 00000000000..37b780a19ad --- /dev/null +++ b/tests/baselines/reference/asyncInterface_es5.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es5/asyncInterface_es5.ts === +async interface I { +>I : I +} diff --git a/tests/baselines/reference/asyncInterface_es6.symbols b/tests/baselines/reference/asyncInterface_es6.symbols new file mode 100644 index 00000000000..9a09798a755 --- /dev/null +++ b/tests/baselines/reference/asyncInterface_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/asyncInterface_es6.ts === +async interface I { +>I : Symbol(I, Decl(asyncInterface_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncInterface_es6.types b/tests/baselines/reference/asyncInterface_es6.types new file mode 100644 index 00000000000..b770cafdb96 --- /dev/null +++ b/tests/baselines/reference/asyncInterface_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/asyncInterface_es6.ts === +async interface I { +>I : I +} diff --git a/tests/baselines/reference/asyncModule_es5.symbols b/tests/baselines/reference/asyncModule_es5.symbols new file mode 100644 index 00000000000..521d6e26b23 --- /dev/null +++ b/tests/baselines/reference/asyncModule_es5.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es5/asyncModule_es5.ts === +async module M { +>M : Symbol(M, Decl(asyncModule_es5.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncModule_es5.types b/tests/baselines/reference/asyncModule_es5.types new file mode 100644 index 00000000000..ee956e48eb3 --- /dev/null +++ b/tests/baselines/reference/asyncModule_es5.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es5/asyncModule_es5.ts === +async module M { +>M : any +} diff --git a/tests/baselines/reference/asyncModule_es6.symbols b/tests/baselines/reference/asyncModule_es6.symbols new file mode 100644 index 00000000000..3a1ebc8fcf6 --- /dev/null +++ b/tests/baselines/reference/asyncModule_es6.symbols @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/asyncModule_es6.ts === +async module M { +>M : Symbol(M, Decl(asyncModule_es6.ts, 0, 0)) +} diff --git a/tests/baselines/reference/asyncModule_es6.types b/tests/baselines/reference/asyncModule_es6.types new file mode 100644 index 00000000000..b502433758a --- /dev/null +++ b/tests/baselines/reference/asyncModule_es6.types @@ -0,0 +1,4 @@ +=== tests/cases/conformance/async/es6/asyncModule_es6.ts === +async module M { +>M : any +} diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols b/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols new file mode 100644 index 00000000000..86f14f2da74 --- /dev/null +++ b/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols @@ -0,0 +1,17 @@ +=== tests/cases/conformance/async/es6/asyncQualifiedReturnType_es6.ts === +namespace X { +>X : Symbol(X, Decl(asyncQualifiedReturnType_es6.ts, 0, 0)) + + export class MyPromise extends Promise { +>MyPromise : Symbol(MyPromise, Decl(asyncQualifiedReturnType_es6.ts, 0, 13)) +>T : Symbol(T, Decl(asyncQualifiedReturnType_es6.ts, 1, 27)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>T : Symbol(T, Decl(asyncQualifiedReturnType_es6.ts, 1, 27)) + } +} + +async function f(): X.MyPromise { +>f : Symbol(f, Decl(asyncQualifiedReturnType_es6.ts, 3, 1)) +>X : Symbol(X, Decl(asyncQualifiedReturnType_es6.ts, 0, 0)) +>MyPromise : Symbol(X.MyPromise, Decl(asyncQualifiedReturnType_es6.ts, 0, 13)) +} diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es6.types b/tests/baselines/reference/asyncQualifiedReturnType_es6.types new file mode 100644 index 00000000000..3b438eb93b6 --- /dev/null +++ b/tests/baselines/reference/asyncQualifiedReturnType_es6.types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/async/es6/asyncQualifiedReturnType_es6.ts === +namespace X { +>X : typeof X + + export class MyPromise extends Promise { +>MyPromise : MyPromise +>T : T +>Promise : Promise +>T : T + } +} + +async function f(): X.MyPromise { +>f : () => X.MyPromise +>X : any +>MyPromise : X.MyPromise +} diff --git a/tests/baselines/reference/asyncSetter_es5.symbols b/tests/baselines/reference/asyncSetter_es5.symbols new file mode 100644 index 00000000000..c07af2778c5 --- /dev/null +++ b/tests/baselines/reference/asyncSetter_es5.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es5/asyncSetter_es5.ts === +class C { +>C : Symbol(C, Decl(asyncSetter_es5.ts, 0, 0)) + + async set foo(value) { +>foo : Symbol(C.foo, Decl(asyncSetter_es5.ts, 0, 9)) +>value : Symbol(value, Decl(asyncSetter_es5.ts, 1, 16)) + } +} diff --git a/tests/baselines/reference/asyncSetter_es5.types b/tests/baselines/reference/asyncSetter_es5.types new file mode 100644 index 00000000000..cd6c0b6677f --- /dev/null +++ b/tests/baselines/reference/asyncSetter_es5.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es5/asyncSetter_es5.ts === +class C { +>C : C + + async set foo(value) { +>foo : any +>value : any + } +} diff --git a/tests/baselines/reference/asyncSetter_es6.symbols b/tests/baselines/reference/asyncSetter_es6.symbols new file mode 100644 index 00000000000..fa37e5bacc0 --- /dev/null +++ b/tests/baselines/reference/asyncSetter_es6.symbols @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es6/asyncSetter_es6.ts === +class C { +>C : Symbol(C, Decl(asyncSetter_es6.ts, 0, 0)) + + async set foo(value) { +>foo : Symbol(C.foo, Decl(asyncSetter_es6.ts, 0, 9)) +>value : Symbol(value, Decl(asyncSetter_es6.ts, 1, 16)) + } +} diff --git a/tests/baselines/reference/asyncSetter_es6.types b/tests/baselines/reference/asyncSetter_es6.types new file mode 100644 index 00000000000..99a4a25cbda --- /dev/null +++ b/tests/baselines/reference/asyncSetter_es6.types @@ -0,0 +1,9 @@ +=== tests/cases/conformance/async/es6/asyncSetter_es6.ts === +class C { +>C : C + + async set foo(value) { +>foo : any +>value : any + } +} diff --git a/tests/baselines/reference/augmentExportEquals1.symbols b/tests/baselines/reference/augmentExportEquals1.symbols new file mode 100644 index 00000000000..84ec06ca7fe --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals1.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/file3.ts === +import x = require("./file1"); +>x : Symbol(x, Decl(file3.ts, 0, 0)) + +import "./file2"; +let a: x.A; // should not work +>a : Symbol(a, Decl(file3.ts, 2, 3)) + +=== tests/cases/compiler/file1.ts === +var x = 1; +>x : Symbol(x, Decl(file1.ts, 0, 3)) + +export = x; +>x : Symbol(x, Decl(file1.ts, 0, 3)) + +=== tests/cases/compiler/file2.ts === +import x = require("./file1"); +>x : Symbol(x, Decl(file2.ts, 0, 0)) + +// augmentation for './file1' +// should error since './file1' does not have namespace meaning +declare module "./file1" { + interface A { a } +>A : Symbol(A, Decl(file2.ts, 4, 26)) +>a : Symbol(A.a, Decl(file2.ts, 5, 17)) +} + diff --git a/tests/baselines/reference/augmentExportEquals1.types b/tests/baselines/reference/augmentExportEquals1.types new file mode 100644 index 00000000000..afb5dd1edc9 --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals1.types @@ -0,0 +1,30 @@ +=== tests/cases/compiler/file3.ts === +import x = require("./file1"); +>x : number + +import "./file2"; +let a: x.A; // should not work +>a : any +>x : any +>A : No type information available! + +=== tests/cases/compiler/file1.ts === +var x = 1; +>x : number +>1 : 1 + +export = x; +>x : number + +=== tests/cases/compiler/file2.ts === +import x = require("./file1"); +>x : number + +// augmentation for './file1' +// should error since './file1' does not have namespace meaning +declare module "./file1" { + interface A { a } +>A : A +>a : any +} + diff --git a/tests/baselines/reference/augmentExportEquals1_1.symbols b/tests/baselines/reference/augmentExportEquals1_1.symbols new file mode 100644 index 00000000000..df793ca841c --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals1_1.symbols @@ -0,0 +1,30 @@ +=== tests/cases/compiler/file3.ts === +import x = require("file1"); +>x : Symbol(x, Decl(file3.ts, 0, 0)) + +import "file2"; +let a: x.A; // should not work +>a : Symbol(a, Decl(file3.ts, 2, 3)) + +=== tests/cases/compiler/file1.d.ts === +declare module "file1" { + var x: number; +>x : Symbol(x, Decl(file1.d.ts, 1, 7)) + + export = x; +>x : Symbol(x, Decl(file1.d.ts, 1, 7)) +} + +=== tests/cases/compiler/file2.ts === +/// +import x = require("file1"); +>x : Symbol(x, Decl(file2.ts, 0, 0)) + +// augmentation for 'file1' +// should error since 'file1' does not have namespace meaning +declare module "file1" { + interface A { a } +>A : Symbol(A, Decl(file2.ts, 5, 24)) +>a : Symbol(A.a, Decl(file2.ts, 6, 17)) +} + diff --git a/tests/baselines/reference/augmentExportEquals1_1.types b/tests/baselines/reference/augmentExportEquals1_1.types new file mode 100644 index 00000000000..f771e815743 --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals1_1.types @@ -0,0 +1,32 @@ +=== tests/cases/compiler/file3.ts === +import x = require("file1"); +>x : number + +import "file2"; +let a: x.A; // should not work +>a : any +>x : any +>A : No type information available! + +=== tests/cases/compiler/file1.d.ts === +declare module "file1" { + var x: number; +>x : number + + export = x; +>x : number +} + +=== tests/cases/compiler/file2.ts === +/// +import x = require("file1"); +>x : number + +// augmentation for 'file1' +// should error since 'file1' does not have namespace meaning +declare module "file1" { + interface A { a } +>A : A +>a : any +} + diff --git a/tests/baselines/reference/augmentExportEquals2.symbols b/tests/baselines/reference/augmentExportEquals2.symbols new file mode 100644 index 00000000000..29f85da0e1f --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals2.symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/file3.ts === +import x = require("./file1"); +>x : Symbol(x, Decl(file3.ts, 0, 0)) + +import "./file2"; +let a: x.A; // should not work +>a : Symbol(a, Decl(file3.ts, 2, 3)) + +=== tests/cases/compiler/file1.ts === +function foo() {} +>foo : Symbol(foo, Decl(file1.ts, 0, 0)) + +export = foo; +>foo : Symbol(foo, Decl(file1.ts, 0, 0)) + +=== tests/cases/compiler/file2.ts === +import x = require("./file1"); +>x : Symbol(x, Decl(file2.ts, 0, 0)) + +// should error since './file1' does not have namespace meaning +declare module "./file1" { + interface A { a } +>A : Symbol(A, Decl(file2.ts, 3, 26)) +>a : Symbol(A.a, Decl(file2.ts, 4, 17)) +} + diff --git a/tests/baselines/reference/augmentExportEquals2.types b/tests/baselines/reference/augmentExportEquals2.types new file mode 100644 index 00000000000..658579598ae --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals2.types @@ -0,0 +1,28 @@ +=== tests/cases/compiler/file3.ts === +import x = require("./file1"); +>x : () => void + +import "./file2"; +let a: x.A; // should not work +>a : any +>x : any +>A : No type information available! + +=== tests/cases/compiler/file1.ts === +function foo() {} +>foo : () => void + +export = foo; +>foo : () => void + +=== tests/cases/compiler/file2.ts === +import x = require("./file1"); +>x : () => void + +// should error since './file1' does not have namespace meaning +declare module "./file1" { + interface A { a } +>A : A +>a : any +} + diff --git a/tests/baselines/reference/augmentExportEquals2_1.symbols b/tests/baselines/reference/augmentExportEquals2_1.symbols new file mode 100644 index 00000000000..99ce1e5c85c --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals2_1.symbols @@ -0,0 +1,29 @@ +=== tests/cases/compiler/file3.ts === +import x = require("file1"); +>x : Symbol(x, Decl(file3.ts, 0, 0)) + +import "file2"; +let a: x.A; // should not work +>a : Symbol(a, Decl(file3.ts, 2, 3)) + +=== tests/cases/compiler/file1.d.ts === +declare module "file1" { + function foo(): void; +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24)) + + export = foo; +>foo : Symbol(foo, Decl(file1.d.ts, 0, 24)) +} + +=== tests/cases/compiler/file2.ts === +/// +import x = require("file1"); +>x : Symbol(x, Decl(file2.ts, 0, 0)) + +// should error since './file1' does not have namespace meaning +declare module "file1" { + interface A { a } +>A : Symbol(A, Decl(file2.ts, 4, 24)) +>a : Symbol(A.a, Decl(file2.ts, 5, 17)) +} + diff --git a/tests/baselines/reference/augmentExportEquals2_1.types b/tests/baselines/reference/augmentExportEquals2_1.types new file mode 100644 index 00000000000..e47ed79f584 --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals2_1.types @@ -0,0 +1,31 @@ +=== tests/cases/compiler/file3.ts === +import x = require("file1"); +>x : () => void + +import "file2"; +let a: x.A; // should not work +>a : any +>x : any +>A : No type information available! + +=== tests/cases/compiler/file1.d.ts === +declare module "file1" { + function foo(): void; +>foo : () => void + + export = foo; +>foo : () => void +} + +=== tests/cases/compiler/file2.ts === +/// +import x = require("file1"); +>x : () => void + +// should error since './file1' does not have namespace meaning +declare module "file1" { + interface A { a } +>A : A +>a : any +} + diff --git a/tests/baselines/reference/augmentExportEquals7.symbols b/tests/baselines/reference/augmentExportEquals7.symbols new file mode 100644 index 00000000000..42156dafaed --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals7.symbols @@ -0,0 +1,19 @@ +=== /node_modules/lib/index.d.ts === +declare var lib: () => void; +>lib : Symbol(lib, Decl(index.d.ts, 0, 11), Decl(index.d.ts, 0, 28)) + +declare namespace lib {} +>lib : Symbol(lib, Decl(index.d.ts, 0, 11), Decl(index.d.ts, 0, 28)) + +export = lib; +>lib : Symbol(lib, Decl(index.d.ts, 0, 11), Decl(index.d.ts, 0, 28)) + +=== /node_modules/@types/lib-extender/index.d.ts === +import * as lib from "lib"; +>lib : Symbol(lib, Decl(index.d.ts, 0, 6)) + +declare module "lib" { + export function fn(): void; +>fn : Symbol(fn, Decl(index.d.ts, 1, 22)) +} + diff --git a/tests/baselines/reference/augmentExportEquals7.types b/tests/baselines/reference/augmentExportEquals7.types new file mode 100644 index 00000000000..f2870eab8df --- /dev/null +++ b/tests/baselines/reference/augmentExportEquals7.types @@ -0,0 +1,19 @@ +=== /node_modules/lib/index.d.ts === +declare var lib: () => void; +>lib : () => void + +declare namespace lib {} +>lib : () => void + +export = lib; +>lib : () => void + +=== /node_modules/@types/lib-extender/index.d.ts === +import * as lib from "lib"; +>lib : () => void + +declare module "lib" { + export function fn(): void; +>fn : () => void +} + diff --git a/tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.symbols b/tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.symbols new file mode 100644 index 00000000000..ddb2f9cb85c --- /dev/null +++ b/tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.symbols @@ -0,0 +1,13 @@ +=== tests/cases/compiler/augmentedClassWithPrototypePropertyOnModule.ts === +declare module m { +>m : Symbol(m, Decl(augmentedClassWithPrototypePropertyOnModule.ts, 0, 0), Decl(augmentedClassWithPrototypePropertyOnModule.ts, 3, 1)) + + var f; +>f : Symbol(f, Decl(augmentedClassWithPrototypePropertyOnModule.ts, 1, 7)) + + var prototype; // This should be error since prototype would be static property on class m +>prototype : Symbol(m.prototype, Decl(augmentedClassWithPrototypePropertyOnModule.ts, 2, 7)) +} +declare class m { +>m : Symbol(m, Decl(augmentedClassWithPrototypePropertyOnModule.ts, 0, 0), Decl(augmentedClassWithPrototypePropertyOnModule.ts, 3, 1)) +} diff --git a/tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.types b/tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.types new file mode 100644 index 00000000000..4437ab706f6 --- /dev/null +++ b/tests/baselines/reference/augmentedClassWithPrototypePropertyOnModule.types @@ -0,0 +1,13 @@ +=== tests/cases/compiler/augmentedClassWithPrototypePropertyOnModule.ts === +declare module m { +>m : typeof m + + var f; +>f : any + + var prototype; // This should be error since prototype would be static property on class m +>prototype : any +} +declare class m { +>m : m +} diff --git a/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.symbols b/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.symbols new file mode 100644 index 00000000000..6057cef5c8f --- /dev/null +++ b/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/types/members/augmentedTypeAssignmentCompatIndexSignature.ts === +interface Foo { a } +>Foo : Symbol(Foo, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 0, 0)) +>a : Symbol(Foo.a, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 0, 15)) + +interface Bar { b } +>Bar : Symbol(Bar, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 0, 19)) +>b : Symbol(Bar.b, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 1, 15)) + +interface Object { +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 1, 19)) + + [n: number]: Foo; +>n : Symbol(n, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 4, 5)) +>Foo : Symbol(Foo, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 0, 0)) +} + +interface Function { +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 5, 1)) + + [n: number]: Bar; +>n : Symbol(n, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 8, 5)) +>Bar : Symbol(Bar, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 0, 19)) +} + +var o = {}; +>o : Symbol(o, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 11, 3)) + +var f = () => { }; +>f : Symbol(f, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 12, 3)) + +var v1: { +>v1 : Symbol(v1, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 14, 3)) + + [n: number]: Foo +>n : Symbol(n, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 15, 5)) +>Foo : Symbol(Foo, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 0, 0)) + +} = o; // Should be allowed +>o : Symbol(o, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 11, 3)) + +var v2: { +>v2 : Symbol(v2, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 18, 3)) + + [n: number]: Bar +>n : Symbol(n, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 19, 5)) +>Bar : Symbol(Bar, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 0, 19)) + +} = f; // Should be allowed +>f : Symbol(f, Decl(augmentedTypeAssignmentCompatIndexSignature.ts, 12, 3)) + diff --git a/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.types b/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.types new file mode 100644 index 00000000000..fc19672442a --- /dev/null +++ b/tests/baselines/reference/augmentedTypeAssignmentCompatIndexSignature.types @@ -0,0 +1,53 @@ +=== tests/cases/conformance/types/members/augmentedTypeAssignmentCompatIndexSignature.ts === +interface Foo { a } +>Foo : Foo +>a : any + +interface Bar { b } +>Bar : Bar +>b : any + +interface Object { +>Object : Object + + [n: number]: Foo; +>n : number +>Foo : Foo +} + +interface Function { +>Function : Function + + [n: number]: Bar; +>n : number +>Bar : Bar +} + +var o = {}; +>o : {} +>{} : {} + +var f = () => { }; +>f : () => void +>() => { } : () => void + +var v1: { +>v1 : { [n: number]: Foo; } + + [n: number]: Foo +>n : number +>Foo : Foo + +} = o; // Should be allowed +>o : {} + +var v2: { +>v2 : { [n: number]: Bar; } + + [n: number]: Bar +>n : number +>Bar : Bar + +} = f; // Should be allowed +>f : () => void + diff --git a/tests/baselines/reference/augmentedTypesClass.symbols b/tests/baselines/reference/augmentedTypesClass.symbols new file mode 100644 index 00000000000..0f867f3dead --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/augmentedTypesClass.ts === +//// class then var +class c1 { public foo() { } } +>c1 : Symbol(c1, Decl(augmentedTypesClass.ts, 0, 0)) +>foo : Symbol(c1.foo, Decl(augmentedTypesClass.ts, 1, 10)) + +var c1 = 1; // error +>c1 : Symbol(c1, Decl(augmentedTypesClass.ts, 2, 3)) + +//// class then enum +class c4 { public foo() { } } +>c4 : Symbol(c4, Decl(augmentedTypesClass.ts, 2, 11)) +>foo : Symbol(c4.foo, Decl(augmentedTypesClass.ts, 5, 10)) + +enum c4 { One } // error +>c4 : Symbol(c4, Decl(augmentedTypesClass.ts, 5, 29)) +>One : Symbol(c4.One, Decl(augmentedTypesClass.ts, 6, 9)) + diff --git a/tests/baselines/reference/augmentedTypesClass.types b/tests/baselines/reference/augmentedTypesClass.types new file mode 100644 index 00000000000..6bee329d24e --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/augmentedTypesClass.ts === +//// class then var +class c1 { public foo() { } } +>c1 : c1 +>foo : () => void + +var c1 = 1; // error +>c1 : number +>1 : 1 + +//// class then enum +class c4 { public foo() { } } +>c4 : c4 +>foo : () => void + +enum c4 { One } // error +>c4 : c4 +>One : c4 + diff --git a/tests/baselines/reference/augmentedTypesClass2.symbols b/tests/baselines/reference/augmentedTypesClass2.symbols new file mode 100644 index 00000000000..a9fbf1a4a13 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass2.symbols @@ -0,0 +1,48 @@ +=== tests/cases/compiler/augmentedTypesClass2.ts === +// Checking class with other things in type space not value space + +// class then interface +class c11 { +>c11 : Symbol(c11, Decl(augmentedTypesClass2.ts, 0, 0), Decl(augmentedTypesClass2.ts, 7, 1)) + + foo() { +>foo : Symbol(c11.foo, Decl(augmentedTypesClass2.ts, 3, 11)) + + return 1; + } +} + +interface c11 { +>c11 : Symbol(c11, Decl(augmentedTypesClass2.ts, 0, 0), Decl(augmentedTypesClass2.ts, 7, 1)) + + bar(): void; +>bar : Symbol(c11.bar, Decl(augmentedTypesClass2.ts, 9, 15)) +} + +// class then class - covered +// class then enum +class c33 { +>c33 : Symbol(c33, Decl(augmentedTypesClass2.ts, 11, 1)) + + foo() { +>foo : Symbol(c33.foo, Decl(augmentedTypesClass2.ts, 15, 11)) + + return 1; + } +} +enum c33 { One }; +>c33 : Symbol(c33, Decl(augmentedTypesClass2.ts, 19, 1)) +>One : Symbol(c33.One, Decl(augmentedTypesClass2.ts, 20, 10)) + +// class then import +class c44 { +>c44 : Symbol(c44, Decl(augmentedTypesClass2.ts, 20, 17)) + + foo() { +>foo : Symbol(c44.foo, Decl(augmentedTypesClass2.ts, 23, 11)) + + return 1; + } +} + + diff --git a/tests/baselines/reference/augmentedTypesClass2.types b/tests/baselines/reference/augmentedTypesClass2.types new file mode 100644 index 00000000000..dd3263cc0a2 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass2.types @@ -0,0 +1,51 @@ +=== tests/cases/compiler/augmentedTypesClass2.ts === +// Checking class with other things in type space not value space + +// class then interface +class c11 { +>c11 : c11 + + foo() { +>foo : () => number + + return 1; +>1 : 1 + } +} + +interface c11 { +>c11 : c11 + + bar(): void; +>bar : () => void +} + +// class then class - covered +// class then enum +class c33 { +>c33 : c33 + + foo() { +>foo : () => number + + return 1; +>1 : 1 + } +} +enum c33 { One }; +>c33 : c33 +>One : c33 + +// class then import +class c44 { +>c44 : c44 + + foo() { +>foo : () => number + + return 1; +>1 : 1 + } +} + + diff --git a/tests/baselines/reference/augmentedTypesClass2a.symbols b/tests/baselines/reference/augmentedTypesClass2a.symbols new file mode 100644 index 00000000000..78acabbbb4f --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass2a.symbols @@ -0,0 +1,12 @@ +=== tests/cases/compiler/augmentedTypesClass2a.ts === +//// class then function +class c2 { public foo() { } } // error +>c2 : Symbol(c2, Decl(augmentedTypesClass2a.ts, 0, 0)) +>foo : Symbol(c2.foo, Decl(augmentedTypesClass2a.ts, 1, 10)) + +function c2() { } // error +>c2 : Symbol(c2, Decl(augmentedTypesClass2a.ts, 1, 29)) + +var c2 = () => { } +>c2 : Symbol(c2, Decl(augmentedTypesClass2a.ts, 3, 3)) + diff --git a/tests/baselines/reference/augmentedTypesClass2a.types b/tests/baselines/reference/augmentedTypesClass2a.types new file mode 100644 index 00000000000..156d4975d04 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass2a.types @@ -0,0 +1,13 @@ +=== tests/cases/compiler/augmentedTypesClass2a.ts === +//// class then function +class c2 { public foo() { } } // error +>c2 : c2 +>foo : () => void + +function c2() { } // error +>c2 : () => void + +var c2 = () => { } +>c2 : () => void +>() => { } : () => void + diff --git a/tests/baselines/reference/augmentedTypesClass4.symbols b/tests/baselines/reference/augmentedTypesClass4.symbols new file mode 100644 index 00000000000..220545b6e00 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass4.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/augmentedTypesClass4.ts === +//// class then class +class c3 { public foo() { } } // error +>c3 : Symbol(c3, Decl(augmentedTypesClass4.ts, 0, 0)) +>foo : Symbol(c3.foo, Decl(augmentedTypesClass4.ts, 1, 10)) + +class c3 { public bar() { } } // error +>c3 : Symbol(c3, Decl(augmentedTypesClass4.ts, 1, 29)) +>bar : Symbol(c3.bar, Decl(augmentedTypesClass4.ts, 2, 10)) + diff --git a/tests/baselines/reference/augmentedTypesClass4.types b/tests/baselines/reference/augmentedTypesClass4.types new file mode 100644 index 00000000000..934d2314464 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesClass4.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/augmentedTypesClass4.ts === +//// class then class +class c3 { public foo() { } } // error +>c3 : c3 +>foo : () => void + +class c3 { public bar() { } } // error +>c3 : c3 +>bar : () => void + diff --git a/tests/baselines/reference/augmentedTypesEnum.symbols b/tests/baselines/reference/augmentedTypesEnum.symbols new file mode 100644 index 00000000000..b0d24b1be39 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesEnum.symbols @@ -0,0 +1,77 @@ +=== tests/cases/compiler/augmentedTypesEnum.ts === +// enum then var +enum e1111 { One } // error +>e1111 : Symbol(e1111, Decl(augmentedTypesEnum.ts, 0, 0)) +>One : Symbol(e1111.One, Decl(augmentedTypesEnum.ts, 1, 12)) + +var e1111 = 1; // error +>e1111 : Symbol(e1111, Decl(augmentedTypesEnum.ts, 2, 3)) + +// enum then function +enum e2 { One } // error +>e2 : Symbol(e2, Decl(augmentedTypesEnum.ts, 2, 14)) +>One : Symbol(e2.One, Decl(augmentedTypesEnum.ts, 5, 9)) + +function e2() { } // error +>e2 : Symbol(e2, Decl(augmentedTypesEnum.ts, 5, 15)) + +enum e3 { One } // error +>e3 : Symbol(e3, Decl(augmentedTypesEnum.ts, 6, 17)) +>One : Symbol(e3.One, Decl(augmentedTypesEnum.ts, 8, 9)) + +var e3 = () => { } // error +>e3 : Symbol(e3, Decl(augmentedTypesEnum.ts, 9, 3)) + +// enum then class +enum e4 { One } // error +>e4 : Symbol(e4, Decl(augmentedTypesEnum.ts, 9, 18)) +>One : Symbol(e4.One, Decl(augmentedTypesEnum.ts, 12, 9)) + +class e4 { public foo() { } } // error +>e4 : Symbol(e4, Decl(augmentedTypesEnum.ts, 12, 15)) +>foo : Symbol(e4.foo, Decl(augmentedTypesEnum.ts, 13, 10)) + +// enum then enum +enum e5 { One } +>e5 : Symbol(e5, Decl(augmentedTypesEnum.ts, 13, 29), Decl(augmentedTypesEnum.ts, 16, 15)) +>One : Symbol(e5.One, Decl(augmentedTypesEnum.ts, 16, 9)) + +enum e5 { Two } // error +>e5 : Symbol(e5, Decl(augmentedTypesEnum.ts, 13, 29), Decl(augmentedTypesEnum.ts, 16, 15)) +>Two : Symbol(e5.Two, Decl(augmentedTypesEnum.ts, 17, 9)) + +enum e5a { One } // error +>e5a : Symbol(e5a, Decl(augmentedTypesEnum.ts, 17, 15), Decl(augmentedTypesEnum.ts, 19, 16)) +>One : Symbol(e5a.One, Decl(augmentedTypesEnum.ts, 19, 10)) + +enum e5a { One } // error +>e5a : Symbol(e5a, Decl(augmentedTypesEnum.ts, 17, 15), Decl(augmentedTypesEnum.ts, 19, 16)) +>One : Symbol(e5a.One, Decl(augmentedTypesEnum.ts, 20, 10)) + +// enum then internal module +enum e6 { One } +>e6 : Symbol(e6, Decl(augmentedTypesEnum.ts, 20, 16), Decl(augmentedTypesEnum.ts, 23, 15)) +>One : Symbol(e6.One, Decl(augmentedTypesEnum.ts, 23, 9)) + +module e6 { } // ok +>e6 : Symbol(e6, Decl(augmentedTypesEnum.ts, 20, 16), Decl(augmentedTypesEnum.ts, 23, 15)) + +enum e6a { One } +>e6a : Symbol(e6a, Decl(augmentedTypesEnum.ts, 24, 13), Decl(augmentedTypesEnum.ts, 26, 16)) +>One : Symbol(e6a.One, Decl(augmentedTypesEnum.ts, 26, 10)) + +module e6a { var y = 2; } // should be error +>e6a : Symbol(e6a, Decl(augmentedTypesEnum.ts, 24, 13), Decl(augmentedTypesEnum.ts, 26, 16)) +>y : Symbol(y, Decl(augmentedTypesEnum.ts, 27, 16)) + +enum e6b { One } +>e6b : Symbol(e6b, Decl(augmentedTypesEnum.ts, 27, 25), Decl(augmentedTypesEnum.ts, 29, 16)) +>One : Symbol(e6b.One, Decl(augmentedTypesEnum.ts, 29, 10)) + +module e6b { export var y = 2; } // should be error +>e6b : Symbol(e6b, Decl(augmentedTypesEnum.ts, 27, 25), Decl(augmentedTypesEnum.ts, 29, 16)) +>y : Symbol(y, Decl(augmentedTypesEnum.ts, 30, 23)) + +// enum then import, messes with error reporting +//enum e7 { One } +//import e7 = require(''); // should be error diff --git a/tests/baselines/reference/augmentedTypesEnum.types b/tests/baselines/reference/augmentedTypesEnum.types new file mode 100644 index 00000000000..36ac647e4a1 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesEnum.types @@ -0,0 +1,81 @@ +=== tests/cases/compiler/augmentedTypesEnum.ts === +// enum then var +enum e1111 { One } // error +>e1111 : e1111 +>One : e1111 + +var e1111 = 1; // error +>e1111 : number +>1 : 1 + +// enum then function +enum e2 { One } // error +>e2 : e2 +>One : e2 + +function e2() { } // error +>e2 : () => void + +enum e3 { One } // error +>e3 : e3 +>One : e3 + +var e3 = () => { } // error +>e3 : () => void +>() => { } : () => void + +// enum then class +enum e4 { One } // error +>e4 : e4 +>One : e4 + +class e4 { public foo() { } } // error +>e4 : e4 +>foo : () => void + +// enum then enum +enum e5 { One } +>e5 : e5 +>One : e5 + +enum e5 { Two } // error +>e5 : e5 +>Two : e5 + +enum e5a { One } // error +>e5a : e5a +>One : e5a + +enum e5a { One } // error +>e5a : e5a +>One : e5a + +// enum then internal module +enum e6 { One } +>e6 : e6 +>One : e6 + +module e6 { } // ok +>e6 : typeof e6 + +enum e6a { One } +>e6a : e6a +>One : e6a + +module e6a { var y = 2; } // should be error +>e6a : typeof e6a +>y : number +>2 : 2 + +enum e6b { One } +>e6b : e6b +>One : e6b + +module e6b { export var y = 2; } // should be error +>e6b : typeof e6b +>y : number +>2 : 2 + +// enum then import, messes with error reporting +//enum e7 { One } +//import e7 = require(''); // should be error diff --git a/tests/baselines/reference/augmentedTypesEnum2.symbols b/tests/baselines/reference/augmentedTypesEnum2.symbols new file mode 100644 index 00000000000..eb65b4bab62 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesEnum2.symbols @@ -0,0 +1,32 @@ +=== tests/cases/compiler/augmentedTypesEnum2.ts === +// enum then interface +enum e1 { One } // error +>e1 : Symbol(e1, Decl(augmentedTypesEnum2.ts, 0, 0)) +>One : Symbol(e1.One, Decl(augmentedTypesEnum2.ts, 1, 9)) + +interface e1 { // error +>e1 : Symbol(e1, Decl(augmentedTypesEnum2.ts, 1, 15)) + + foo(): void; +>foo : Symbol(e1.foo, Decl(augmentedTypesEnum2.ts, 3, 14)) +} + +// interface then enum works + +// enum then class +enum e2 { One }; // error +>e2 : Symbol(e2, Decl(augmentedTypesEnum2.ts, 5, 1)) +>One : Symbol(e2.One, Decl(augmentedTypesEnum2.ts, 10, 9)) + +class e2 { // error +>e2 : Symbol(e2, Decl(augmentedTypesEnum2.ts, 10, 16)) + + foo() { +>foo : Symbol(e2.foo, Decl(augmentedTypesEnum2.ts, 11, 10)) + + return 1; + } +} + +//enum then enum - covered +//enum then import - covered diff --git a/tests/baselines/reference/augmentedTypesEnum2.types b/tests/baselines/reference/augmentedTypesEnum2.types new file mode 100644 index 00000000000..9949862b147 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesEnum2.types @@ -0,0 +1,33 @@ +=== tests/cases/compiler/augmentedTypesEnum2.ts === +// enum then interface +enum e1 { One } // error +>e1 : e1 +>One : e1 + +interface e1 { // error +>e1 : e1 + + foo(): void; +>foo : () => void +} + +// interface then enum works + +// enum then class +enum e2 { One }; // error +>e2 : e2 +>One : e2 + +class e2 { // error +>e2 : e2 + + foo() { +>foo : () => number + + return 1; +>1 : 1 + } +} + +//enum then enum - covered +//enum then import - covered diff --git a/tests/baselines/reference/augmentedTypesEnum3.symbols b/tests/baselines/reference/augmentedTypesEnum3.symbols new file mode 100644 index 00000000000..d5e6155969d --- /dev/null +++ b/tests/baselines/reference/augmentedTypesEnum3.symbols @@ -0,0 +1,41 @@ +=== tests/cases/compiler/augmentedTypesEnum3.ts === +module E { +>E : Symbol(E, Decl(augmentedTypesEnum3.ts, 0, 0), Decl(augmentedTypesEnum3.ts, 2, 1)) + + var t; +>t : Symbol(t, Decl(augmentedTypesEnum3.ts, 1, 7)) +} +enum E { } +>E : Symbol(E, Decl(augmentedTypesEnum3.ts, 0, 0), Decl(augmentedTypesEnum3.ts, 2, 1)) + +enum F { } +>F : Symbol(F, Decl(augmentedTypesEnum3.ts, 3, 10), Decl(augmentedTypesEnum3.ts, 5, 10)) + +module F { var t; } +>F : Symbol(F, Decl(augmentedTypesEnum3.ts, 3, 10), Decl(augmentedTypesEnum3.ts, 5, 10)) +>t : Symbol(t, Decl(augmentedTypesEnum3.ts, 6, 14)) + +module A { +>A : Symbol(A, Decl(augmentedTypesEnum3.ts, 6, 19), Decl(augmentedTypesEnum3.ts, 10, 1), Decl(augmentedTypesEnum3.ts, 13, 1), Decl(augmentedTypesEnum3.ts, 16, 1)) + + var o; +>o : Symbol(o, Decl(augmentedTypesEnum3.ts, 9, 7)) +} +enum A { +>A : Symbol(A, Decl(augmentedTypesEnum3.ts, 6, 19), Decl(augmentedTypesEnum3.ts, 10, 1), Decl(augmentedTypesEnum3.ts, 13, 1), Decl(augmentedTypesEnum3.ts, 16, 1)) + + b +>b : Symbol(A.b, Decl(augmentedTypesEnum3.ts, 11, 8)) +} +enum A { +>A : Symbol(A, Decl(augmentedTypesEnum3.ts, 6, 19), Decl(augmentedTypesEnum3.ts, 10, 1), Decl(augmentedTypesEnum3.ts, 13, 1), Decl(augmentedTypesEnum3.ts, 16, 1)) + + c +>c : Symbol(A.c, Decl(augmentedTypesEnum3.ts, 14, 8)) +} +module A { +>A : Symbol(A, Decl(augmentedTypesEnum3.ts, 6, 19), Decl(augmentedTypesEnum3.ts, 10, 1), Decl(augmentedTypesEnum3.ts, 13, 1), Decl(augmentedTypesEnum3.ts, 16, 1)) + + var p; +>p : Symbol(p, Decl(augmentedTypesEnum3.ts, 18, 7)) +} diff --git a/tests/baselines/reference/augmentedTypesEnum3.types b/tests/baselines/reference/augmentedTypesEnum3.types new file mode 100644 index 00000000000..d3c2e933506 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesEnum3.types @@ -0,0 +1,41 @@ +=== tests/cases/compiler/augmentedTypesEnum3.ts === +module E { +>E : typeof E + + var t; +>t : any +} +enum E { } +>E : E + +enum F { } +>F : F + +module F { var t; } +>F : typeof F +>t : any + +module A { +>A : typeof A + + var o; +>o : any +} +enum A { +>A : A + + b +>b : A +} +enum A { +>A : A + + c +>c : A +} +module A { +>A : typeof A + + var p; +>p : any +} diff --git a/tests/baselines/reference/augmentedTypesFunction.symbols b/tests/baselines/reference/augmentedTypesFunction.symbols new file mode 100644 index 00000000000..8f202847cd3 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesFunction.symbols @@ -0,0 +1,75 @@ +=== tests/cases/compiler/augmentedTypesFunction.ts === +// function then var +function y1() { } // error +>y1 : Symbol(y1, Decl(augmentedTypesFunction.ts, 0, 0)) + +var y1 = 1; // error +>y1 : Symbol(y1, Decl(augmentedTypesFunction.ts, 2, 3)) + +// function then function +function y2() { } // error +>y2 : Symbol(y2, Decl(augmentedTypesFunction.ts, 2, 11), Decl(augmentedTypesFunction.ts, 5, 17)) + +function y2() { } // error +>y2 : Symbol(y2, Decl(augmentedTypesFunction.ts, 2, 11), Decl(augmentedTypesFunction.ts, 5, 17)) + +function y2a() { } // error +>y2a : Symbol(y2a, Decl(augmentedTypesFunction.ts, 6, 17)) + +var y2a = () => { } // error +>y2a : Symbol(y2a, Decl(augmentedTypesFunction.ts, 9, 3)) + +// function then class +function y3() { } // error +>y3 : Symbol(y3, Decl(augmentedTypesFunction.ts, 9, 19)) + +class y3 { } // error +>y3 : Symbol(y3, Decl(augmentedTypesFunction.ts, 12, 17)) + +function y3a() { } // error +>y3a : Symbol(y3a, Decl(augmentedTypesFunction.ts, 13, 12)) + +class y3a { public foo() { } } // error +>y3a : Symbol(y3a, Decl(augmentedTypesFunction.ts, 15, 18)) +>foo : Symbol(y3a.foo, Decl(augmentedTypesFunction.ts, 16, 11)) + +// function then enum +function y4() { } // error +>y4 : Symbol(y4, Decl(augmentedTypesFunction.ts, 16, 30)) + +enum y4 { One } // error +>y4 : Symbol(y4, Decl(augmentedTypesFunction.ts, 19, 17)) +>One : Symbol(y4.One, Decl(augmentedTypesFunction.ts, 20, 9)) + +// function then internal module +function y5() { } +>y5 : Symbol(y5, Decl(augmentedTypesFunction.ts, 20, 15), Decl(augmentedTypesFunction.ts, 23, 17)) + +module y5 { } // ok since module is not instantiated +>y5 : Symbol(y5, Decl(augmentedTypesFunction.ts, 20, 15), Decl(augmentedTypesFunction.ts, 23, 17)) + +function y5a() { } +>y5a : Symbol(y5a, Decl(augmentedTypesFunction.ts, 24, 13), Decl(augmentedTypesFunction.ts, 26, 18)) + +module y5a { var y = 2; } // should be an error +>y5a : Symbol(y5a, Decl(augmentedTypesFunction.ts, 24, 13), Decl(augmentedTypesFunction.ts, 26, 18)) +>y : Symbol(y, Decl(augmentedTypesFunction.ts, 27, 16)) + +function y5b() { } +>y5b : Symbol(y5b, Decl(augmentedTypesFunction.ts, 27, 25), Decl(augmentedTypesFunction.ts, 29, 18)) + +module y5b { export var y = 3; } // should be an error +>y5b : Symbol(y5b, Decl(augmentedTypesFunction.ts, 27, 25), Decl(augmentedTypesFunction.ts, 29, 18)) +>y : Symbol(y, Decl(augmentedTypesFunction.ts, 30, 23)) + +function y5c() { } +>y5c : Symbol(y5c, Decl(augmentedTypesFunction.ts, 30, 32), Decl(augmentedTypesFunction.ts, 32, 18)) + +module y5c { export interface I { foo(): void } } // should be an error +>y5c : Symbol(y5c, Decl(augmentedTypesFunction.ts, 30, 32), Decl(augmentedTypesFunction.ts, 32, 18)) +>I : Symbol(I, Decl(augmentedTypesFunction.ts, 33, 12)) +>foo : Symbol(I.foo, Decl(augmentedTypesFunction.ts, 33, 33)) + +// function then import, messes with other errors +//function y6() { } +//import y6 = require(''); diff --git a/tests/baselines/reference/augmentedTypesFunction.types b/tests/baselines/reference/augmentedTypesFunction.types new file mode 100644 index 00000000000..a977761c83f --- /dev/null +++ b/tests/baselines/reference/augmentedTypesFunction.types @@ -0,0 +1,79 @@ +=== tests/cases/compiler/augmentedTypesFunction.ts === +// function then var +function y1() { } // error +>y1 : () => void + +var y1 = 1; // error +>y1 : number +>1 : 1 + +// function then function +function y2() { } // error +>y2 : () => void + +function y2() { } // error +>y2 : () => void + +function y2a() { } // error +>y2a : () => void + +var y2a = () => { } // error +>y2a : () => void +>() => { } : () => void + +// function then class +function y3() { } // error +>y3 : () => void + +class y3 { } // error +>y3 : y3 + +function y3a() { } // error +>y3a : () => void + +class y3a { public foo() { } } // error +>y3a : y3a +>foo : () => void + +// function then enum +function y4() { } // error +>y4 : () => void + +enum y4 { One } // error +>y4 : y4 +>One : y4 + +// function then internal module +function y5() { } +>y5 : () => void + +module y5 { } // ok since module is not instantiated +>y5 : () => void + +function y5a() { } +>y5a : typeof y5a + +module y5a { var y = 2; } // should be an error +>y5a : typeof y5a +>y : number +>2 : 2 + +function y5b() { } +>y5b : typeof y5b + +module y5b { export var y = 3; } // should be an error +>y5b : typeof y5b +>y : number +>3 : 3 + +function y5c() { } +>y5c : () => void + +module y5c { export interface I { foo(): void } } // should be an error +>y5c : () => void +>I : I +>foo : () => void + +// function then import, messes with other errors +//function y6() { } +//import y6 = require(''); diff --git a/tests/baselines/reference/augmentedTypesInterface.symbols b/tests/baselines/reference/augmentedTypesInterface.symbols new file mode 100644 index 00000000000..602823e27c9 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesInterface.symbols @@ -0,0 +1,55 @@ +=== tests/cases/compiler/augmentedTypesInterface.ts === +// interface then interface + +interface i { +>i : Symbol(i, Decl(augmentedTypesInterface.ts, 0, 0), Decl(augmentedTypesInterface.ts, 4, 1)) + + foo(): void; +>foo : Symbol(i.foo, Decl(augmentedTypesInterface.ts, 2, 13)) +} + +interface i { +>i : Symbol(i, Decl(augmentedTypesInterface.ts, 0, 0), Decl(augmentedTypesInterface.ts, 4, 1)) + + bar(): number; +>bar : Symbol(i.bar, Decl(augmentedTypesInterface.ts, 6, 13)) +} + +// interface then class +interface i2 { +>i2 : Symbol(i2, Decl(augmentedTypesInterface.ts, 8, 1), Decl(augmentedTypesInterface.ts, 13, 1)) + + foo(): void; +>foo : Symbol(i2.foo, Decl(augmentedTypesInterface.ts, 11, 14)) +} + +class i2 { +>i2 : Symbol(i2, Decl(augmentedTypesInterface.ts, 8, 1), Decl(augmentedTypesInterface.ts, 13, 1)) + + bar() { +>bar : Symbol(i2.bar, Decl(augmentedTypesInterface.ts, 15, 10)) + + return 1; + } +} + +// interface then enum +interface i3 { // error +>i3 : Symbol(i3, Decl(augmentedTypesInterface.ts, 19, 1)) + + foo(): void; +>foo : Symbol(i3.foo, Decl(augmentedTypesInterface.ts, 22, 14)) +} +enum i3 { One }; // error +>i3 : Symbol(i3, Decl(augmentedTypesInterface.ts, 24, 1)) +>One : Symbol(i3.One, Decl(augmentedTypesInterface.ts, 25, 9)) + +// interface then import +interface i4 { +>i4 : Symbol(i4, Decl(augmentedTypesInterface.ts, 25, 16)) + + foo(): void; +>foo : Symbol(i4.foo, Decl(augmentedTypesInterface.ts, 28, 14)) +} + +//import i4 = require(''); // error diff --git a/tests/baselines/reference/augmentedTypesInterface.types b/tests/baselines/reference/augmentedTypesInterface.types new file mode 100644 index 00000000000..412d4795131 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesInterface.types @@ -0,0 +1,56 @@ +=== tests/cases/compiler/augmentedTypesInterface.ts === +// interface then interface + +interface i { +>i : i + + foo(): void; +>foo : () => void +} + +interface i { +>i : i + + bar(): number; +>bar : () => number +} + +// interface then class +interface i2 { +>i2 : i2 + + foo(): void; +>foo : () => void +} + +class i2 { +>i2 : i2 + + bar() { +>bar : () => number + + return 1; +>1 : 1 + } +} + +// interface then enum +interface i3 { // error +>i3 : i3 + + foo(): void; +>foo : () => void +} +enum i3 { One }; // error +>i3 : i3 +>One : i3 + +// interface then import +interface i4 { +>i4 : i4 + + foo(): void; +>foo : () => void +} + +//import i4 = require(''); // error diff --git a/tests/baselines/reference/augmentedTypesModules.symbols b/tests/baselines/reference/augmentedTypesModules.symbols new file mode 100644 index 00000000000..70ab734c9a6 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesModules.symbols @@ -0,0 +1,224 @@ +=== tests/cases/compiler/augmentedTypesModules.ts === +// module then var +module m1 { } +>m1 : Symbol(m1, Decl(augmentedTypesModules.ts, 0, 0), Decl(augmentedTypesModules.ts, 2, 3)) + +var m1 = 1; // Should be allowed +>m1 : Symbol(m1, Decl(augmentedTypesModules.ts, 0, 0), Decl(augmentedTypesModules.ts, 2, 3)) + +module m1a { var y = 2; } // error +>m1a : Symbol(m1a, Decl(augmentedTypesModules.ts, 2, 11)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 4, 16)) + +var m1a = 1; // error +>m1a : Symbol(m1a, Decl(augmentedTypesModules.ts, 5, 3)) + +module m1b { export var y = 2; } // error +>m1b : Symbol(m1b, Decl(augmentedTypesModules.ts, 5, 12)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 7, 23)) + +var m1b = 1; // error +>m1b : Symbol(m1b, Decl(augmentedTypesModules.ts, 8, 3)) + +module m1c { +>m1c : Symbol(m1c, Decl(augmentedTypesModules.ts, 8, 12), Decl(augmentedTypesModules.ts, 13, 3)) + + export interface I { foo(): void; } +>I : Symbol(I, Decl(augmentedTypesModules.ts, 10, 12)) +>foo : Symbol(I.foo, Decl(augmentedTypesModules.ts, 11, 24)) +} +var m1c = 1; // Should be allowed +>m1c : Symbol(m1c, Decl(augmentedTypesModules.ts, 8, 12), Decl(augmentedTypesModules.ts, 13, 3)) + +module m1d { // error +>m1d : Symbol(m1d, Decl(augmentedTypesModules.ts, 13, 12)) + + export class I { foo() { } } +>I : Symbol(I, Decl(augmentedTypesModules.ts, 15, 12)) +>foo : Symbol(I.foo, Decl(augmentedTypesModules.ts, 16, 20)) +} +var m1d = 1; // error +>m1d : Symbol(m1d, Decl(augmentedTypesModules.ts, 18, 3)) + +// module then function +module m2 { } +>m2 : Symbol(m2, Decl(augmentedTypesModules.ts, 18, 12), Decl(augmentedTypesModules.ts, 21, 13)) + +function m2() { }; // ok since the module is not instantiated +>m2 : Symbol(m2, Decl(augmentedTypesModules.ts, 18, 12), Decl(augmentedTypesModules.ts, 21, 13)) + +module m2a { var y = 2; } +>m2a : Symbol(m2a, Decl(augmentedTypesModules.ts, 22, 18), Decl(augmentedTypesModules.ts, 24, 25)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 24, 16)) + +function m2a() { }; // error since the module is instantiated +>m2a : Symbol(m2a, Decl(augmentedTypesModules.ts, 22, 18), Decl(augmentedTypesModules.ts, 24, 25)) + +module m2b { export var y = 2; } +>m2b : Symbol(m2b, Decl(augmentedTypesModules.ts, 25, 19), Decl(augmentedTypesModules.ts, 27, 32)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 27, 23)) + +function m2b() { }; // error since the module is instantiated +>m2b : Symbol(m2b, Decl(augmentedTypesModules.ts, 25, 19), Decl(augmentedTypesModules.ts, 27, 32)) + +// should be errors to have function first +function m2c() { }; +>m2c : Symbol(m2c, Decl(augmentedTypesModules.ts, 28, 19), Decl(augmentedTypesModules.ts, 31, 19)) + +module m2c { export var y = 2; } +>m2c : Symbol(m2c, Decl(augmentedTypesModules.ts, 28, 19), Decl(augmentedTypesModules.ts, 31, 19)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 32, 23)) + +module m2d { } +>m2d : Symbol(m2d, Decl(augmentedTypesModules.ts, 32, 32), Decl(augmentedTypesModules.ts, 34, 14)) + +declare function m2d(): void; +>m2d : Symbol(m2d, Decl(augmentedTypesModules.ts, 32, 32), Decl(augmentedTypesModules.ts, 34, 14)) + +declare function m2e(): void; +>m2e : Symbol(m2e, Decl(augmentedTypesModules.ts, 35, 29), Decl(augmentedTypesModules.ts, 37, 29)) + +module m2e { } +>m2e : Symbol(m2e, Decl(augmentedTypesModules.ts, 35, 29), Decl(augmentedTypesModules.ts, 37, 29)) + +function m2f() { }; +>m2f : Symbol(m2f, Decl(augmentedTypesModules.ts, 38, 14), Decl(augmentedTypesModules.ts, 40, 19)) + +module m2f { export interface I { foo(): void } } +>m2f : Symbol(m2f, Decl(augmentedTypesModules.ts, 38, 14), Decl(augmentedTypesModules.ts, 40, 19)) +>I : Symbol(I, Decl(augmentedTypesModules.ts, 41, 12)) +>foo : Symbol(I.foo, Decl(augmentedTypesModules.ts, 41, 33)) + +function m2g() { }; +>m2g : Symbol(m2g, Decl(augmentedTypesModules.ts, 41, 49), Decl(augmentedTypesModules.ts, 43, 19)) + +module m2g { export class C { foo() { } } } +>m2g : Symbol(m2g, Decl(augmentedTypesModules.ts, 41, 49), Decl(augmentedTypesModules.ts, 43, 19)) +>C : Symbol(C, Decl(augmentedTypesModules.ts, 44, 12)) +>foo : Symbol(C.foo, Decl(augmentedTypesModules.ts, 44, 29)) + +// module then class +module m3 { } +>m3 : Symbol(m3, Decl(augmentedTypesModules.ts, 44, 43), Decl(augmentedTypesModules.ts, 47, 13)) + +class m3 { } // ok since the module is not instantiated +>m3 : Symbol(m3, Decl(augmentedTypesModules.ts, 44, 43), Decl(augmentedTypesModules.ts, 47, 13)) + +module m3a { var y = 2; } +>m3a : Symbol(m3a, Decl(augmentedTypesModules.ts, 48, 12), Decl(augmentedTypesModules.ts, 50, 25)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 50, 16)) + +class m3a { foo() { } } // error, class isn't ambient or declared before the module +>m3a : Symbol(m3a, Decl(augmentedTypesModules.ts, 48, 12), Decl(augmentedTypesModules.ts, 50, 25)) +>foo : Symbol(m3a.foo, Decl(augmentedTypesModules.ts, 51, 11)) + +class m3b { foo() { } } +>m3b : Symbol(m3b, Decl(augmentedTypesModules.ts, 51, 23), Decl(augmentedTypesModules.ts, 53, 23)) +>foo : Symbol(m3b.foo, Decl(augmentedTypesModules.ts, 53, 11)) + +module m3b { var y = 2; } +>m3b : Symbol(m3b, Decl(augmentedTypesModules.ts, 51, 23), Decl(augmentedTypesModules.ts, 53, 23)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 54, 16)) + +class m3c { foo() { } } +>m3c : Symbol(m3c, Decl(augmentedTypesModules.ts, 54, 25), Decl(augmentedTypesModules.ts, 56, 23)) +>foo : Symbol(m3c.foo, Decl(augmentedTypesModules.ts, 56, 11)) + +module m3c { export var y = 2; } +>m3c : Symbol(m3c, Decl(augmentedTypesModules.ts, 54, 25), Decl(augmentedTypesModules.ts, 56, 23)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 57, 23)) + +declare class m3d { foo(): void } +>m3d : Symbol(m3d, Decl(augmentedTypesModules.ts, 57, 32), Decl(augmentedTypesModules.ts, 59, 33)) +>foo : Symbol(m3d.foo, Decl(augmentedTypesModules.ts, 59, 19)) + +module m3d { export var y = 2; } +>m3d : Symbol(m3d, Decl(augmentedTypesModules.ts, 57, 32), Decl(augmentedTypesModules.ts, 59, 33)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 60, 23)) + +module m3e { export var y = 2; } +>m3e : Symbol(m3e, Decl(augmentedTypesModules.ts, 60, 32), Decl(augmentedTypesModules.ts, 62, 32)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 62, 23)) + +declare class m3e { foo(): void } +>m3e : Symbol(m3e, Decl(augmentedTypesModules.ts, 60, 32), Decl(augmentedTypesModules.ts, 62, 32)) +>foo : Symbol(m3e.foo, Decl(augmentedTypesModules.ts, 63, 19)) + +declare class m3f { foo(): void } +>m3f : Symbol(m3f, Decl(augmentedTypesModules.ts, 63, 33), Decl(augmentedTypesModules.ts, 65, 33)) +>foo : Symbol(m3f.foo, Decl(augmentedTypesModules.ts, 65, 19)) + +module m3f { export interface I { foo(): void } } +>m3f : Symbol(m3f, Decl(augmentedTypesModules.ts, 63, 33), Decl(augmentedTypesModules.ts, 65, 33)) +>I : Symbol(I, Decl(augmentedTypesModules.ts, 66, 12)) +>foo : Symbol(I.foo, Decl(augmentedTypesModules.ts, 66, 33)) + +declare class m3g { foo(): void } +>m3g : Symbol(m3g, Decl(augmentedTypesModules.ts, 66, 49), Decl(augmentedTypesModules.ts, 68, 33)) +>foo : Symbol(m3g.foo, Decl(augmentedTypesModules.ts, 68, 19)) + +module m3g { export class C { foo() { } } } +>m3g : Symbol(m3g, Decl(augmentedTypesModules.ts, 66, 49), Decl(augmentedTypesModules.ts, 68, 33)) +>C : Symbol(C, Decl(augmentedTypesModules.ts, 69, 12)) +>foo : Symbol(C.foo, Decl(augmentedTypesModules.ts, 69, 29)) + +// module then enum +// should be errors +module m4 { } +>m4 : Symbol(m4, Decl(augmentedTypesModules.ts, 69, 43), Decl(augmentedTypesModules.ts, 73, 13)) + +enum m4 { } +>m4 : Symbol(m4, Decl(augmentedTypesModules.ts, 69, 43), Decl(augmentedTypesModules.ts, 73, 13)) + +module m4a { var y = 2; } +>m4a : Symbol(m4a, Decl(augmentedTypesModules.ts, 74, 11), Decl(augmentedTypesModules.ts, 76, 25)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 76, 16)) + +enum m4a { One } +>m4a : Symbol(m4a, Decl(augmentedTypesModules.ts, 74, 11), Decl(augmentedTypesModules.ts, 76, 25)) +>One : Symbol(m4a.One, Decl(augmentedTypesModules.ts, 77, 10)) + +module m4b { export var y = 2; } +>m4b : Symbol(m4b, Decl(augmentedTypesModules.ts, 77, 16), Decl(augmentedTypesModules.ts, 79, 32)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 79, 23)) + +enum m4b { One } +>m4b : Symbol(m4b, Decl(augmentedTypesModules.ts, 77, 16), Decl(augmentedTypesModules.ts, 79, 32)) +>One : Symbol(m4b.One, Decl(augmentedTypesModules.ts, 80, 10)) + +module m4c { interface I { foo(): void } } +>m4c : Symbol(m4c, Decl(augmentedTypesModules.ts, 80, 16), Decl(augmentedTypesModules.ts, 82, 42)) +>I : Symbol(I, Decl(augmentedTypesModules.ts, 82, 12)) +>foo : Symbol(I.foo, Decl(augmentedTypesModules.ts, 82, 26)) + +enum m4c { One } +>m4c : Symbol(m4c, Decl(augmentedTypesModules.ts, 80, 16), Decl(augmentedTypesModules.ts, 82, 42)) +>One : Symbol(m4c.One, Decl(augmentedTypesModules.ts, 83, 10)) + +module m4d { class C { foo() { } } } +>m4d : Symbol(m4d, Decl(augmentedTypesModules.ts, 83, 16), Decl(augmentedTypesModules.ts, 85, 36)) +>C : Symbol(C, Decl(augmentedTypesModules.ts, 85, 12)) +>foo : Symbol(C.foo, Decl(augmentedTypesModules.ts, 85, 22)) + +enum m4d { One } +>m4d : Symbol(m4d, Decl(augmentedTypesModules.ts, 83, 16), Decl(augmentedTypesModules.ts, 85, 36)) +>One : Symbol(m4d.One, Decl(augmentedTypesModules.ts, 86, 10)) + +//// module then module + +module m5 { export var y = 2; } +>m5 : Symbol(m5, Decl(augmentedTypesModules.ts, 86, 16), Decl(augmentedTypesModules.ts, 90, 31)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 90, 22)) + +module m5 { export interface I { foo(): void } } // should already be reasonably well covered +>m5 : Symbol(m5, Decl(augmentedTypesModules.ts, 86, 16), Decl(augmentedTypesModules.ts, 90, 31)) +>I : Symbol(I, Decl(augmentedTypesModules.ts, 91, 11)) +>foo : Symbol(I.foo, Decl(augmentedTypesModules.ts, 91, 32)) + +// module then import +module m6 { export var y = 2; } +>m6 : Symbol(m6, Decl(augmentedTypesModules.ts, 91, 48)) +>y : Symbol(y, Decl(augmentedTypesModules.ts, 94, 22)) + +//import m6 = require(''); + diff --git a/tests/baselines/reference/augmentedTypesModules.types b/tests/baselines/reference/augmentedTypesModules.types new file mode 100644 index 00000000000..4dc23acd66f --- /dev/null +++ b/tests/baselines/reference/augmentedTypesModules.types @@ -0,0 +1,243 @@ +=== tests/cases/compiler/augmentedTypesModules.ts === +// module then var +module m1 { } +>m1 : number + +var m1 = 1; // Should be allowed +>m1 : number +>1 : 1 + +module m1a { var y = 2; } // error +>m1a : typeof m1a +>y : number +>2 : 2 + +var m1a = 1; // error +>m1a : number +>1 : 1 + +module m1b { export var y = 2; } // error +>m1b : typeof m1b +>y : number +>2 : 2 + +var m1b = 1; // error +>m1b : number +>1 : 1 + +module m1c { +>m1c : number + + export interface I { foo(): void; } +>I : I +>foo : () => void +} +var m1c = 1; // Should be allowed +>m1c : number +>1 : 1 + +module m1d { // error +>m1d : typeof m1d + + export class I { foo() { } } +>I : I +>foo : () => void +} +var m1d = 1; // error +>m1d : number +>1 : 1 + +// module then function +module m2 { } +>m2 : () => void + +function m2() { }; // ok since the module is not instantiated +>m2 : () => void + +module m2a { var y = 2; } +>m2a : typeof m2a +>y : number +>2 : 2 + +function m2a() { }; // error since the module is instantiated +>m2a : typeof m2a + +module m2b { export var y = 2; } +>m2b : typeof m2b +>y : number +>2 : 2 + +function m2b() { }; // error since the module is instantiated +>m2b : typeof m2b + +// should be errors to have function first +function m2c() { }; +>m2c : typeof m2c + +module m2c { export var y = 2; } +>m2c : typeof m2c +>y : number +>2 : 2 + +module m2d { } +>m2d : () => void + +declare function m2d(): void; +>m2d : () => void + +declare function m2e(): void; +>m2e : () => void + +module m2e { } +>m2e : () => void + +function m2f() { }; +>m2f : () => void + +module m2f { export interface I { foo(): void } } +>m2f : () => void +>I : I +>foo : () => void + +function m2g() { }; +>m2g : typeof m2g + +module m2g { export class C { foo() { } } } +>m2g : typeof m2g +>C : C +>foo : () => void + +// module then class +module m3 { } +>m3 : typeof m3 + +class m3 { } // ok since the module is not instantiated +>m3 : m3 + +module m3a { var y = 2; } +>m3a : typeof m3a +>y : number +>2 : 2 + +class m3a { foo() { } } // error, class isn't ambient or declared before the module +>m3a : m3a +>foo : () => void + +class m3b { foo() { } } +>m3b : m3b +>foo : () => void + +module m3b { var y = 2; } +>m3b : typeof m3b +>y : number +>2 : 2 + +class m3c { foo() { } } +>m3c : m3c +>foo : () => void + +module m3c { export var y = 2; } +>m3c : typeof m3c +>y : number +>2 : 2 + +declare class m3d { foo(): void } +>m3d : m3d +>foo : () => void + +module m3d { export var y = 2; } +>m3d : typeof m3d +>y : number +>2 : 2 + +module m3e { export var y = 2; } +>m3e : typeof m3e +>y : number +>2 : 2 + +declare class m3e { foo(): void } +>m3e : m3e +>foo : () => void + +declare class m3f { foo(): void } +>m3f : m3f +>foo : () => void + +module m3f { export interface I { foo(): void } } +>m3f : typeof m3f +>I : I +>foo : () => void + +declare class m3g { foo(): void } +>m3g : m3g +>foo : () => void + +module m3g { export class C { foo() { } } } +>m3g : typeof m3g +>C : C +>foo : () => void + +// module then enum +// should be errors +module m4 { } +>m4 : typeof m4 + +enum m4 { } +>m4 : m4 + +module m4a { var y = 2; } +>m4a : typeof m4a +>y : number +>2 : 2 + +enum m4a { One } +>m4a : m4a +>One : m4a + +module m4b { export var y = 2; } +>m4b : typeof m4b +>y : number +>2 : 2 + +enum m4b { One } +>m4b : m4b +>One : m4b + +module m4c { interface I { foo(): void } } +>m4c : typeof m4c +>I : I +>foo : () => void + +enum m4c { One } +>m4c : m4c +>One : m4c + +module m4d { class C { foo() { } } } +>m4d : typeof m4d +>C : C +>foo : () => void + +enum m4d { One } +>m4d : m4d +>One : m4d + +//// module then module + +module m5 { export var y = 2; } +>m5 : typeof m5 +>y : number +>2 : 2 + +module m5 { export interface I { foo(): void } } // should already be reasonably well covered +>m5 : typeof m5 +>I : I +>foo : () => void + +// module then import +module m6 { export var y = 2; } +>m6 : typeof m6 +>y : number +>2 : 2 + +//import m6 = require(''); + diff --git a/tests/baselines/reference/augmentedTypesModules2.symbols b/tests/baselines/reference/augmentedTypesModules2.symbols new file mode 100644 index 00000000000..79d6bff4d50 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesModules2.symbols @@ -0,0 +1,64 @@ +=== tests/cases/compiler/augmentedTypesModules2.ts === +// module then function +module m2 { } +>m2 : Symbol(m2, Decl(augmentedTypesModules2.ts, 0, 0), Decl(augmentedTypesModules2.ts, 1, 13)) + +function m2() { }; // ok since the module is not instantiated +>m2 : Symbol(m2, Decl(augmentedTypesModules2.ts, 0, 0), Decl(augmentedTypesModules2.ts, 1, 13)) + +module m2a { var y = 2; } +>m2a : Symbol(m2a, Decl(augmentedTypesModules2.ts, 2, 18), Decl(augmentedTypesModules2.ts, 4, 25)) +>y : Symbol(y, Decl(augmentedTypesModules2.ts, 4, 16)) + +function m2a() { }; // error since the module is instantiated +>m2a : Symbol(m2a, Decl(augmentedTypesModules2.ts, 2, 18), Decl(augmentedTypesModules2.ts, 4, 25)) + +module m2b { export var y = 2; } +>m2b : Symbol(m2b, Decl(augmentedTypesModules2.ts, 5, 19), Decl(augmentedTypesModules2.ts, 7, 32)) +>y : Symbol(y, Decl(augmentedTypesModules2.ts, 7, 23)) + +function m2b() { }; // error since the module is instantiated +>m2b : Symbol(m2b, Decl(augmentedTypesModules2.ts, 5, 19), Decl(augmentedTypesModules2.ts, 7, 32)) + +function m2c() { }; +>m2c : Symbol(m2c, Decl(augmentedTypesModules2.ts, 8, 19), Decl(augmentedTypesModules2.ts, 10, 19)) + +module m2c { export var y = 2; } +>m2c : Symbol(m2c, Decl(augmentedTypesModules2.ts, 8, 19), Decl(augmentedTypesModules2.ts, 10, 19)) +>y : Symbol(y, Decl(augmentedTypesModules2.ts, 11, 23)) + +module m2cc { export var y = 2; } +>m2cc : Symbol(m2cc, Decl(augmentedTypesModules2.ts, 11, 32), Decl(augmentedTypesModules2.ts, 13, 33)) +>y : Symbol(y, Decl(augmentedTypesModules2.ts, 13, 24)) + +function m2cc() { }; // error to have module first +>m2cc : Symbol(m2cc, Decl(augmentedTypesModules2.ts, 11, 32), Decl(augmentedTypesModules2.ts, 13, 33)) + +module m2d { } +>m2d : Symbol(m2d, Decl(augmentedTypesModules2.ts, 14, 20), Decl(augmentedTypesModules2.ts, 16, 14)) + +declare function m2d(): void; +>m2d : Symbol(m2d, Decl(augmentedTypesModules2.ts, 14, 20), Decl(augmentedTypesModules2.ts, 16, 14)) + +declare function m2e(): void; +>m2e : Symbol(m2e, Decl(augmentedTypesModules2.ts, 17, 29), Decl(augmentedTypesModules2.ts, 19, 29)) + +module m2e { } +>m2e : Symbol(m2e, Decl(augmentedTypesModules2.ts, 17, 29), Decl(augmentedTypesModules2.ts, 19, 29)) + +function m2f() { }; +>m2f : Symbol(m2f, Decl(augmentedTypesModules2.ts, 20, 14), Decl(augmentedTypesModules2.ts, 22, 19)) + +module m2f { export interface I { foo(): void } } +>m2f : Symbol(m2f, Decl(augmentedTypesModules2.ts, 20, 14), Decl(augmentedTypesModules2.ts, 22, 19)) +>I : Symbol(I, Decl(augmentedTypesModules2.ts, 23, 12)) +>foo : Symbol(I.foo, Decl(augmentedTypesModules2.ts, 23, 33)) + +function m2g() { }; +>m2g : Symbol(m2g, Decl(augmentedTypesModules2.ts, 23, 49), Decl(augmentedTypesModules2.ts, 25, 19)) + +module m2g { export class C { foo() { } } } +>m2g : Symbol(m2g, Decl(augmentedTypesModules2.ts, 23, 49), Decl(augmentedTypesModules2.ts, 25, 19)) +>C : Symbol(C, Decl(augmentedTypesModules2.ts, 26, 12)) +>foo : Symbol(C.foo, Decl(augmentedTypesModules2.ts, 26, 29)) + diff --git a/tests/baselines/reference/augmentedTypesModules2.types b/tests/baselines/reference/augmentedTypesModules2.types new file mode 100644 index 00000000000..e2c9f7a3cb5 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesModules2.types @@ -0,0 +1,68 @@ +=== tests/cases/compiler/augmentedTypesModules2.ts === +// module then function +module m2 { } +>m2 : () => void + +function m2() { }; // ok since the module is not instantiated +>m2 : () => void + +module m2a { var y = 2; } +>m2a : typeof m2a +>y : number +>2 : 2 + +function m2a() { }; // error since the module is instantiated +>m2a : typeof m2a + +module m2b { export var y = 2; } +>m2b : typeof m2b +>y : number +>2 : 2 + +function m2b() { }; // error since the module is instantiated +>m2b : typeof m2b + +function m2c() { }; +>m2c : typeof m2c + +module m2c { export var y = 2; } +>m2c : typeof m2c +>y : number +>2 : 2 + +module m2cc { export var y = 2; } +>m2cc : typeof m2cc +>y : number +>2 : 2 + +function m2cc() { }; // error to have module first +>m2cc : typeof m2cc + +module m2d { } +>m2d : () => void + +declare function m2d(): void; +>m2d : () => void + +declare function m2e(): void; +>m2e : () => void + +module m2e { } +>m2e : () => void + +function m2f() { }; +>m2f : () => void + +module m2f { export interface I { foo(): void } } +>m2f : () => void +>I : I +>foo : () => void + +function m2g() { }; +>m2g : typeof m2g + +module m2g { export class C { foo() { } } } +>m2g : typeof m2g +>C : C +>foo : () => void + diff --git a/tests/baselines/reference/augmentedTypesModules3.symbols b/tests/baselines/reference/augmentedTypesModules3.symbols new file mode 100644 index 00000000000..e5519b21a98 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesModules3.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/augmentedTypesModules3.ts === +//// module then class +module m3 { } +>m3 : Symbol(m3, Decl(augmentedTypesModules3.ts, 0, 0), Decl(augmentedTypesModules3.ts, 1, 13)) + +class m3 { } // ok since the module is not instantiated +>m3 : Symbol(m3, Decl(augmentedTypesModules3.ts, 0, 0), Decl(augmentedTypesModules3.ts, 1, 13)) + +module m3a { var y = 2; } +>m3a : Symbol(m3a, Decl(augmentedTypesModules3.ts, 2, 12), Decl(augmentedTypesModules3.ts, 4, 25)) +>y : Symbol(y, Decl(augmentedTypesModules3.ts, 4, 16)) + +class m3a { foo() { } } // error, class isn't ambient or declared before the module +>m3a : Symbol(m3a, Decl(augmentedTypesModules3.ts, 2, 12), Decl(augmentedTypesModules3.ts, 4, 25)) +>foo : Symbol(m3a.foo, Decl(augmentedTypesModules3.ts, 5, 11)) + diff --git a/tests/baselines/reference/augmentedTypesModules3.types b/tests/baselines/reference/augmentedTypesModules3.types new file mode 100644 index 00000000000..bf8f275a777 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesModules3.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/augmentedTypesModules3.ts === +//// module then class +module m3 { } +>m3 : typeof m3 + +class m3 { } // ok since the module is not instantiated +>m3 : m3 + +module m3a { var y = 2; } +>m3a : typeof m3a +>y : number +>2 : 2 + +class m3a { foo() { } } // error, class isn't ambient or declared before the module +>m3a : m3a +>foo : () => void + diff --git a/tests/baselines/reference/augmentedTypesVar.symbols b/tests/baselines/reference/augmentedTypesVar.symbols new file mode 100644 index 00000000000..1b9e9be1231 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesVar.symbols @@ -0,0 +1,68 @@ +=== tests/cases/compiler/augmentedTypesVar.ts === +// var then var +var x1 = 1; +>x1 : Symbol(x1, Decl(augmentedTypesVar.ts, 1, 3), Decl(augmentedTypesVar.ts, 2, 3)) + +var x1 = 2; +>x1 : Symbol(x1, Decl(augmentedTypesVar.ts, 1, 3), Decl(augmentedTypesVar.ts, 2, 3)) + +// var then function +var x2 = 1; // error +>x2 : Symbol(x2, Decl(augmentedTypesVar.ts, 5, 3)) + +function x2() { } // error +>x2 : Symbol(x2, Decl(augmentedTypesVar.ts, 5, 11)) + +var x3 = 1; +>x3 : Symbol(x3, Decl(augmentedTypesVar.ts, 8, 3), Decl(augmentedTypesVar.ts, 9, 3)) + +var x3 = () => { } // error +>x3 : Symbol(x3, Decl(augmentedTypesVar.ts, 8, 3), Decl(augmentedTypesVar.ts, 9, 3)) + +// var then class +var x4 = 1; // error +>x4 : Symbol(x4, Decl(augmentedTypesVar.ts, 12, 3)) + +class x4 { } // error +>x4 : Symbol(x4, Decl(augmentedTypesVar.ts, 12, 11)) + +var x4a = 1; // error +>x4a : Symbol(x4a, Decl(augmentedTypesVar.ts, 15, 3)) + +class x4a { public foo() { } } // error +>x4a : Symbol(x4a, Decl(augmentedTypesVar.ts, 15, 12)) +>foo : Symbol(x4a.foo, Decl(augmentedTypesVar.ts, 16, 11)) + +// var then enum +var x5 = 1; +>x5 : Symbol(x5, Decl(augmentedTypesVar.ts, 19, 3)) + +enum x5 { One } // error +>x5 : Symbol(x5, Decl(augmentedTypesVar.ts, 19, 11)) +>One : Symbol(x5.One, Decl(augmentedTypesVar.ts, 20, 9)) + +// var then module +var x6 = 1; +>x6 : Symbol(x6, Decl(augmentedTypesVar.ts, 23, 3), Decl(augmentedTypesVar.ts, 23, 11)) + +module x6 { } // ok since non-instantiated +>x6 : Symbol(x6, Decl(augmentedTypesVar.ts, 23, 3), Decl(augmentedTypesVar.ts, 23, 11)) + +var x6a = 1; // error +>x6a : Symbol(x6a, Decl(augmentedTypesVar.ts, 26, 3)) + +module x6a { var y = 2; } // error since instantiated +>x6a : Symbol(x6a, Decl(augmentedTypesVar.ts, 26, 12)) +>y : Symbol(y, Decl(augmentedTypesVar.ts, 27, 16)) + +var x6b = 1; // error +>x6b : Symbol(x6b, Decl(augmentedTypesVar.ts, 29, 3)) + +module x6b { export var y = 2; } // error +>x6b : Symbol(x6b, Decl(augmentedTypesVar.ts, 29, 12)) +>y : Symbol(y, Decl(augmentedTypesVar.ts, 30, 23)) + +// var then import, messes with other error reporting +//var x7 = 1; +//import x7 = require(''); + diff --git a/tests/baselines/reference/augmentedTypesVar.types b/tests/baselines/reference/augmentedTypesVar.types new file mode 100644 index 00000000000..f666a3ca5a4 --- /dev/null +++ b/tests/baselines/reference/augmentedTypesVar.types @@ -0,0 +1,81 @@ +=== tests/cases/compiler/augmentedTypesVar.ts === +// var then var +var x1 = 1; +>x1 : number +>1 : 1 + +var x1 = 2; +>x1 : number +>2 : 2 + +// var then function +var x2 = 1; // error +>x2 : number +>1 : 1 + +function x2() { } // error +>x2 : () => void + +var x3 = 1; +>x3 : number +>1 : 1 + +var x3 = () => { } // error +>x3 : number +>() => { } : () => void + +// var then class +var x4 = 1; // error +>x4 : number +>1 : 1 + +class x4 { } // error +>x4 : x4 + +var x4a = 1; // error +>x4a : number +>1 : 1 + +class x4a { public foo() { } } // error +>x4a : x4a +>foo : () => void + +// var then enum +var x5 = 1; +>x5 : number +>1 : 1 + +enum x5 { One } // error +>x5 : x5 +>One : x5 + +// var then module +var x6 = 1; +>x6 : number +>1 : 1 + +module x6 { } // ok since non-instantiated +>x6 : number + +var x6a = 1; // error +>x6a : number +>1 : 1 + +module x6a { var y = 2; } // error since instantiated +>x6a : typeof x6a +>y : number +>2 : 2 + +var x6b = 1; // error +>x6b : number +>1 : 1 + +module x6b { export var y = 2; } // error +>x6b : typeof x6b +>y : number +>2 : 2 + +// var then import, messes with other error reporting +//var x7 = 1; +//import x7 = require(''); + diff --git a/tests/baselines/reference/autoLift2.symbols b/tests/baselines/reference/autoLift2.symbols new file mode 100644 index 00000000000..bcb45998d46 --- /dev/null +++ b/tests/baselines/reference/autoLift2.symbols @@ -0,0 +1,52 @@ +=== tests/cases/compiler/autoLift2.ts === +class A +>A : Symbol(A, Decl(autoLift2.ts, 0, 0)) + +{ + constructor() { + this.foo: any; +>this : Symbol(A, Decl(autoLift2.ts, 0, 0)) + + this.bar: any; +>this : Symbol(A, Decl(autoLift2.ts, 0, 0)) + } + + + baz() { +>baz : Symbol(A.baz, Decl(autoLift2.ts, 6, 5)) + + this.foo = "foo"; +>this : Symbol(A, Decl(autoLift2.ts, 0, 0)) + + this.bar = "bar"; +>this : Symbol(A, Decl(autoLift2.ts, 0, 0)) + + [1, 2].forEach((p) => this.foo); +>[1, 2].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>p : Symbol(p, Decl(autoLift2.ts, 15, 21)) +>this : Symbol(A, Decl(autoLift2.ts, 0, 0)) + + [1, 2].forEach((p) => this.bar); +>[1, 2].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>p : Symbol(p, Decl(autoLift2.ts, 17, 21)) +>this : Symbol(A, Decl(autoLift2.ts, 0, 0)) + + } + +} + + + +var a = new A(); +>a : Symbol(a, Decl(autoLift2.ts, 25, 3)) +>A : Symbol(A, Decl(autoLift2.ts, 0, 0)) + +a.baz(); +>a.baz : Symbol(A.baz, Decl(autoLift2.ts, 6, 5)) +>a : Symbol(a, Decl(autoLift2.ts, 25, 3)) +>baz : Symbol(A.baz, Decl(autoLift2.ts, 6, 5)) + + + diff --git a/tests/baselines/reference/autoLift2.types b/tests/baselines/reference/autoLift2.types new file mode 100644 index 00000000000..fe2f34ad8a2 --- /dev/null +++ b/tests/baselines/reference/autoLift2.types @@ -0,0 +1,82 @@ +=== tests/cases/compiler/autoLift2.ts === +class A +>A : A + +{ + constructor() { + this.foo: any; +>this.foo : any +>this : this +>foo : any +>any : any + + this.bar: any; +>this.bar : any +>this : this +>bar : any +>any : any + } + + + baz() { +>baz : () => void + + this.foo = "foo"; +>this.foo = "foo" : "foo" +>this.foo : any +>this : this +>foo : any +>"foo" : "foo" + + this.bar = "bar"; +>this.bar = "bar" : "bar" +>this.bar : any +>this : this +>bar : any +>"bar" : "bar" + + [1, 2].forEach((p) => this.foo); +>[1, 2].forEach((p) => this.foo) : void +>[1, 2].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +>(p) => this.foo : (p: number) => any +>p : number +>this.foo : any +>this : this +>foo : any + + [1, 2].forEach((p) => this.bar); +>[1, 2].forEach((p) => this.bar) : void +>[1, 2].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void +>(p) => this.bar : (p: number) => any +>p : number +>this.bar : any +>this : this +>bar : any + + } + +} + + + +var a = new A(); +>a : A +>new A() : A +>A : typeof A + +a.baz(); +>a.baz() : void +>a.baz : () => void +>a : A +>baz : () => void + + + diff --git a/tests/baselines/reference/autolift3.symbols b/tests/baselines/reference/autolift3.symbols new file mode 100644 index 00000000000..0277ececf08 --- /dev/null +++ b/tests/baselines/reference/autolift3.symbols @@ -0,0 +1,52 @@ +=== tests/cases/compiler/autolift3.ts === +class B { +>B : Symbol(B, Decl(autolift3.ts, 0, 0)) + + constructor() { + function foo() { } +>foo : Symbol(foo, Decl(autolift3.ts, 2, 19)) + + foo(); +>foo : Symbol(foo, Decl(autolift3.ts, 2, 19)) + + var a = 0; +>a : Symbol(a, Decl(autolift3.ts, 7, 11)) + + var inner: any = (function() { +>inner : Symbol(inner, Decl(autolift3.ts, 8, 11)) + + var CScriptIO = (function() { +>CScriptIO : Symbol(CScriptIO, Decl(autolift3.ts, 9, 15)) + + var fso = 0 +>fso : Symbol(fso, Decl(autolift3.ts, 10, 19)) + + return { + readFile: function(path: string): string { +>readFile : Symbol(readFile, Decl(autolift3.ts, 12, 24)) +>path : Symbol(path, Decl(autolift3.ts, 13, 39)) + + return fso.toString(); +>fso.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) +>fso : Symbol(fso, Decl(autolift3.ts, 10, 19)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) + } + } + })(); + return inner; +>inner : Symbol(inner, Decl(autolift3.ts, 8, 11)) + + })(); + } +} + +var b = new B(); +>b : Symbol(b, Decl(autolift3.ts, 23, 3)) +>B : Symbol(B, Decl(autolift3.ts, 0, 0)) + +b.foo(); +>b : Symbol(b, Decl(autolift3.ts, 23, 3)) + + + + diff --git a/tests/baselines/reference/autolift3.types b/tests/baselines/reference/autolift3.types new file mode 100644 index 00000000000..6a4faebdf52 --- /dev/null +++ b/tests/baselines/reference/autolift3.types @@ -0,0 +1,69 @@ +=== tests/cases/compiler/autolift3.ts === +class B { +>B : B + + constructor() { + function foo() { } +>foo : () => void + + foo(); +>foo() : void +>foo : () => void + + var a = 0; +>a : number +>0 : 0 + + var inner: any = (function() { +>inner : any +>(function() { var CScriptIO = (function() { var fso = 0 return { readFile: function(path: string): string { return fso.toString(); } } })(); return inner; })() : any +>(function() { var CScriptIO = (function() { var fso = 0 return { readFile: function(path: string): string { return fso.toString(); } } })(); return inner; }) : () => any +>function() { var CScriptIO = (function() { var fso = 0 return { readFile: function(path: string): string { return fso.toString(); } } })(); return inner; } : () => any + + var CScriptIO = (function() { +>CScriptIO : { readFile: (path: string) => string; } +>(function() { var fso = 0 return { readFile: function(path: string): string { return fso.toString(); } } })() : { readFile: (path: string) => string; } +>(function() { var fso = 0 return { readFile: function(path: string): string { return fso.toString(); } } }) : () => { readFile: (path: string) => string; } +>function() { var fso = 0 return { readFile: function(path: string): string { return fso.toString(); } } } : () => { readFile: (path: string) => string; } + + var fso = 0 +>fso : number +>0 : 0 + + return { +>{ readFile: function(path: string): string { return fso.toString(); } } : { readFile: (path: string) => string; } + + readFile: function(path: string): string { +>readFile : (path: string) => string +>function(path: string): string { return fso.toString(); } : (path: string) => string +>path : string + + return fso.toString(); +>fso.toString() : string +>fso.toString : (radix?: number) => string +>fso : number +>toString : (radix?: number) => string + } + } + })(); + return inner; +>inner : any + + })(); + } +} + +var b = new B(); +>b : B +>new B() : B +>B : typeof B + +b.foo(); +>b.foo() : any +>b.foo : any +>b : B +>foo : any + + + + diff --git a/tests/baselines/reference/autolift4.symbols b/tests/baselines/reference/autolift4.symbols new file mode 100644 index 00000000000..9fc5d6370ba --- /dev/null +++ b/tests/baselines/reference/autolift4.symbols @@ -0,0 +1,77 @@ +=== tests/cases/compiler/autolift4.ts === +class Point { +>Point : Symbol(Point, Decl(autolift4.ts, 0, 0)) + + constructor(public x: number, public y: number) { +>x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) + + } + getDist() { +>getDist : Symbol(Point.getDist, Decl(autolift4.ts, 4, 5)) + + return Math.sqrt(this.x*this.x + this.y*this.y); +>Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) +>this.x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this : Symbol(Point, Decl(autolift4.ts, 0, 0)) +>x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this.x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this : Symbol(Point, Decl(autolift4.ts, 0, 0)) +>x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this.y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) +>this : Symbol(Point, Decl(autolift4.ts, 0, 0)) +>y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) +>this.y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) +>this : Symbol(Point, Decl(autolift4.ts, 0, 0)) +>y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) + } + static origin = new Point(0,0); +>origin : Symbol(Point.origin, Decl(autolift4.ts, 7, 5)) +>Point : Symbol(Point, Decl(autolift4.ts, 0, 0)) +} + +class Point3D extends Point { +>Point3D : Symbol(Point3D, Decl(autolift4.ts, 9, 1)) +>Point : Symbol(Point, Decl(autolift4.ts, 0, 0)) + + constructor(x: number, y: number, public z: number, m:number) { +>x : Symbol(x, Decl(autolift4.ts, 13, 16)) +>y : Symbol(y, Decl(autolift4.ts, 13, 26)) +>z : Symbol(Point3D.z, Decl(autolift4.ts, 13, 37)) +>m : Symbol(m, Decl(autolift4.ts, 13, 55)) + + super(x, y); +>super : Symbol(Point, Decl(autolift4.ts, 0, 0)) +>x : Symbol(x, Decl(autolift4.ts, 13, 16)) +>y : Symbol(y, Decl(autolift4.ts, 13, 26)) + } + + getDist() { +>getDist : Symbol(Point3D.getDist, Decl(autolift4.ts, 15, 5)) + + return Math.sqrt(this.x*this.x + this.y*this.y + this.z*this.m); +>Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, --, --)) +>this.x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this : Symbol(Point3D, Decl(autolift4.ts, 9, 1)) +>x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this.x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this : Symbol(Point3D, Decl(autolift4.ts, 9, 1)) +>x : Symbol(Point.x, Decl(autolift4.ts, 2, 16)) +>this.y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) +>this : Symbol(Point3D, Decl(autolift4.ts, 9, 1)) +>y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) +>this.y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) +>this : Symbol(Point3D, Decl(autolift4.ts, 9, 1)) +>y : Symbol(Point.y, Decl(autolift4.ts, 2, 33)) +>this.z : Symbol(Point3D.z, Decl(autolift4.ts, 13, 37)) +>this : Symbol(Point3D, Decl(autolift4.ts, 9, 1)) +>z : Symbol(Point3D.z, Decl(autolift4.ts, 13, 37)) +>this : Symbol(Point3D, Decl(autolift4.ts, 9, 1)) + } +} + + diff --git a/tests/baselines/reference/autolift4.types b/tests/baselines/reference/autolift4.types new file mode 100644 index 00000000000..dc34da815fc --- /dev/null +++ b/tests/baselines/reference/autolift4.types @@ -0,0 +1,93 @@ +=== tests/cases/compiler/autolift4.ts === +class Point { +>Point : Point + + constructor(public x: number, public y: number) { +>x : number +>y : number + + } + getDist() { +>getDist : () => number + + return Math.sqrt(this.x*this.x + this.y*this.y); +>Math.sqrt(this.x*this.x + this.y*this.y) : number +>Math.sqrt : (x: number) => number +>Math : Math +>sqrt : (x: number) => number +>this.x*this.x + this.y*this.y : number +>this.x*this.x : number +>this.x : number +>this : this +>x : number +>this.x : number +>this : this +>x : number +>this.y*this.y : number +>this.y : number +>this : this +>y : number +>this.y : number +>this : this +>y : number + } + static origin = new Point(0,0); +>origin : Point +>new Point(0,0) : Point +>Point : typeof Point +>0 : 0 +>0 : 0 +} + +class Point3D extends Point { +>Point3D : Point3D +>Point : Point + + constructor(x: number, y: number, public z: number, m:number) { +>x : number +>y : number +>z : number +>m : number + + super(x, y); +>super(x, y) : void +>super : typeof Point +>x : number +>y : number + } + + getDist() { +>getDist : () => number + + return Math.sqrt(this.x*this.x + this.y*this.y + this.z*this.m); +>Math.sqrt(this.x*this.x + this.y*this.y + this.z*this.m) : number +>Math.sqrt : (x: number) => number +>Math : Math +>sqrt : (x: number) => number +>this.x*this.x + this.y*this.y + this.z*this.m : number +>this.x*this.x + this.y*this.y : number +>this.x*this.x : number +>this.x : number +>this : this +>x : number +>this.x : number +>this : this +>x : number +>this.y*this.y : number +>this.y : number +>this : this +>y : number +>this.y : number +>this : this +>y : number +>this.z*this.m : number +>this.z : number +>this : this +>z : number +>this.m : any +>this : this +>m : any + } +} + + diff --git a/tests/baselines/reference/awaitLiteralValues.symbols b/tests/baselines/reference/awaitLiteralValues.symbols new file mode 100644 index 00000000000..2f5e8191b20 --- /dev/null +++ b/tests/baselines/reference/awaitLiteralValues.symbols @@ -0,0 +1,38 @@ +=== tests/cases/compiler/awaitLiteralValues.ts === +function awaitString() { +>awaitString : Symbol(awaitString, Decl(awaitLiteralValues.ts, 0, 0)) + + await 'literal'; +} + +function awaitNumber() { +>awaitNumber : Symbol(awaitNumber, Decl(awaitLiteralValues.ts, 2, 1)) + + await 1; +} + +function awaitTrue() { +>awaitTrue : Symbol(awaitTrue, Decl(awaitLiteralValues.ts, 6, 1)) + + await true; +} + +function awaitFalse() { +>awaitFalse : Symbol(awaitFalse, Decl(awaitLiteralValues.ts, 10, 1)) + + await false; +} + +function awaitNull() { +>awaitNull : Symbol(awaitNull, Decl(awaitLiteralValues.ts, 14, 1)) + + await null; +} + +function awaitUndefined() { +>awaitUndefined : Symbol(awaitUndefined, Decl(awaitLiteralValues.ts, 18, 1)) + + await undefined; +>undefined : Symbol(undefined) +} + diff --git a/tests/baselines/reference/awaitLiteralValues.types b/tests/baselines/reference/awaitLiteralValues.types new file mode 100644 index 00000000000..da436d83bd0 --- /dev/null +++ b/tests/baselines/reference/awaitLiteralValues.types @@ -0,0 +1,49 @@ +=== tests/cases/compiler/awaitLiteralValues.ts === +function awaitString() { +>awaitString : () => void + + await 'literal'; +>await 'literal' : "literal" +>'literal' : "literal" +} + +function awaitNumber() { +>awaitNumber : () => void + + await 1; +>await 1 : 1 +>1 : 1 +} + +function awaitTrue() { +>awaitTrue : () => void + + await true; +>await true : true +>true : true +} + +function awaitFalse() { +>awaitFalse : () => void + + await false; +>await false : false +>false : false +} + +function awaitNull() { +>awaitNull : () => void + + await null; +>await null : null +>null : null +} + +function awaitUndefined() { +>awaitUndefined : () => void + + await undefined; +>await undefined : undefined +>undefined : undefined +} + diff --git a/tests/baselines/reference/await_unaryExpression_es2017_1.symbols b/tests/baselines/reference/await_unaryExpression_es2017_1.symbols index 81bb31a7efd..75c3ad6dddd 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_1.symbols +++ b/tests/baselines/reference/await_unaryExpression_es2017_1.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts === - async function bar() { >bar : Symbol(bar, Decl(await_unaryExpression_es2017_1.ts, 0, 0)) @@ -7,25 +6,25 @@ async function bar() { } async function bar1() { ->bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017_1.ts, 3, 1)) +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017_1.ts, 2, 1)) delete await 42; // OK } async function bar2() { ->bar2 : Symbol(bar2, Decl(await_unaryExpression_es2017_1.ts, 7, 1)) +>bar2 : Symbol(bar2, Decl(await_unaryExpression_es2017_1.ts, 6, 1)) delete await 42; // OK } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017_1.ts, 11, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017_1.ts, 10, 1)) void await 42; } async function bar4() { ->bar4 : Symbol(bar4, Decl(await_unaryExpression_es2017_1.ts, 15, 1)) +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es2017_1.ts, 14, 1)) +await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_1.types b/tests/baselines/reference/await_unaryExpression_es2017_1.types index 7afa4fe9001..40b84797069 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_1.types +++ b/tests/baselines/reference/await_unaryExpression_es2017_1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017_1.ts === - async function bar() { >bar : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es2017_2.symbols b/tests/baselines/reference/await_unaryExpression_es2017_2.symbols index d4b8a7493d9..93ff1c1d94f 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_2.symbols +++ b/tests/baselines/reference/await_unaryExpression_es2017_2.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts === - async function bar1() { >bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017_2.ts, 0, 0)) @@ -7,13 +6,13 @@ async function bar1() { } async function bar2() { ->bar2 : Symbol(bar2, Decl(await_unaryExpression_es2017_2.ts, 3, 1)) +>bar2 : Symbol(bar2, Decl(await_unaryExpression_es2017_2.ts, 2, 1)) delete await 42; } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017_2.ts, 7, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017_2.ts, 6, 1)) void await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es2017_2.types b/tests/baselines/reference/await_unaryExpression_es2017_2.types index acaa76d2d67..2c46832d574 100644 --- a/tests/baselines/reference/await_unaryExpression_es2017_2.types +++ b/tests/baselines/reference/await_unaryExpression_es2017_2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es2017/await_unaryExpression_es2017_2.ts === - async function bar1() { >bar1 : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es2017_3.symbols b/tests/baselines/reference/await_unaryExpression_es2017_3.symbols new file mode 100644 index 00000000000..05a4cb4c8ea --- /dev/null +++ b/tests/baselines/reference/await_unaryExpression_es2017_3.symbols @@ -0,0 +1,32 @@ +=== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts === +async function bar1() { +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es2017_3.ts, 0, 0)) + + ++await 42; // Error +} + +async function bar2() { +>bar2 : Symbol(bar2, Decl(await_unaryExpression_es2017_3.ts, 2, 1)) + + --await 42; // Error +} + +async function bar3() { +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es2017_3.ts, 6, 1)) + + var x = 42; +>x : Symbol(x, Decl(await_unaryExpression_es2017_3.ts, 9, 7)) + + await x++; // OK but shouldn't need parenthesis +>x : Symbol(x, Decl(await_unaryExpression_es2017_3.ts, 9, 7)) +} + +async function bar4() { +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es2017_3.ts, 11, 1)) + + var x = 42; +>x : Symbol(x, Decl(await_unaryExpression_es2017_3.ts, 14, 7)) + + await x--; // OK but shouldn't need parenthesis +>x : Symbol(x, Decl(await_unaryExpression_es2017_3.ts, 14, 7)) +} diff --git a/tests/baselines/reference/await_unaryExpression_es2017_3.types b/tests/baselines/reference/await_unaryExpression_es2017_3.types new file mode 100644 index 00000000000..b60ea42b2a0 --- /dev/null +++ b/tests/baselines/reference/await_unaryExpression_es2017_3.types @@ -0,0 +1,46 @@ +=== tests/cases/conformance/async/es2017/await_unaryExpression_es2017_3.ts === +async function bar1() { +>bar1 : () => Promise + + ++await 42; // Error +>++ : number +> : any +>await 42 : 42 +>42 : 42 +} + +async function bar2() { +>bar2 : () => Promise + + --await 42; // Error +>-- : number +> : any +>await 42 : 42 +>42 : 42 +} + +async function bar3() { +>bar3 : () => Promise + + var x = 42; +>x : number +>42 : 42 + + await x++; // OK but shouldn't need parenthesis +>await x++ : number +>x++ : number +>x : number +} + +async function bar4() { +>bar4 : () => Promise + + var x = 42; +>x : number +>42 : 42 + + await x--; // OK but shouldn't need parenthesis +>await x-- : number +>x-- : number +>x : number +} diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.symbols b/tests/baselines/reference/await_unaryExpression_es6_1.symbols index ed7d7e4ed02..a4c33ee825c 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_1.symbols +++ b/tests/baselines/reference/await_unaryExpression_es6_1.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts === - async function bar() { >bar : Symbol(bar, Decl(await_unaryExpression_es6_1.ts, 0, 0)) @@ -7,25 +6,25 @@ async function bar() { } async function bar1() { ->bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_1.ts, 3, 1)) +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_1.ts, 2, 1)) delete await 42; // OK } async function bar2() { ->bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_1.ts, 7, 1)) +>bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_1.ts, 6, 1)) delete await 42; // OK } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_1.ts, 11, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_1.ts, 10, 1)) void await 42; } async function bar4() { ->bar4 : Symbol(bar4, Decl(await_unaryExpression_es6_1.ts, 15, 1)) +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6_1.ts, 14, 1)) +await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.types b/tests/baselines/reference/await_unaryExpression_es6_1.types index 15544420189..a5887f4e472 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_1.types +++ b/tests/baselines/reference/await_unaryExpression_es6_1.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts === - async function bar() { >bar : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.symbols b/tests/baselines/reference/await_unaryExpression_es6_2.symbols index 574ea4d433a..54a48e43ea6 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_2.symbols +++ b/tests/baselines/reference/await_unaryExpression_es6_2.symbols @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts === - async function bar1() { >bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_2.ts, 0, 0)) @@ -7,13 +6,13 @@ async function bar1() { } async function bar2() { ->bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_2.ts, 3, 1)) +>bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_2.ts, 2, 1)) delete await 42; } async function bar3() { ->bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_2.ts, 7, 1)) +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_2.ts, 6, 1)) void await 42; } diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.types b/tests/baselines/reference/await_unaryExpression_es6_2.types index 6142eec825b..15dc820bbbb 100644 --- a/tests/baselines/reference/await_unaryExpression_es6_2.types +++ b/tests/baselines/reference/await_unaryExpression_es6_2.types @@ -1,5 +1,4 @@ === tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts === - async function bar1() { >bar1 : () => Promise diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.symbols b/tests/baselines/reference/await_unaryExpression_es6_3.symbols new file mode 100644 index 00000000000..4d61bfde3c1 --- /dev/null +++ b/tests/baselines/reference/await_unaryExpression_es6_3.symbols @@ -0,0 +1,32 @@ +=== tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts === +async function bar1() { +>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_3.ts, 0, 0)) + + ++await 42; // Error +} + +async function bar2() { +>bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_3.ts, 2, 1)) + + --await 42; // Error +} + +async function bar3() { +>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_3.ts, 6, 1)) + + var x = 42; +>x : Symbol(x, Decl(await_unaryExpression_es6_3.ts, 9, 7)) + + await x++; // OK but shouldn't need parenthesis +>x : Symbol(x, Decl(await_unaryExpression_es6_3.ts, 9, 7)) +} + +async function bar4() { +>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6_3.ts, 11, 1)) + + var x = 42; +>x : Symbol(x, Decl(await_unaryExpression_es6_3.ts, 14, 7)) + + await x--; // OK but shouldn't need parenthesis +>x : Symbol(x, Decl(await_unaryExpression_es6_3.ts, 14, 7)) +} diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.types b/tests/baselines/reference/await_unaryExpression_es6_3.types new file mode 100644 index 00000000000..db18c889553 --- /dev/null +++ b/tests/baselines/reference/await_unaryExpression_es6_3.types @@ -0,0 +1,46 @@ +=== tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts === +async function bar1() { +>bar1 : () => Promise + + ++await 42; // Error +>++ : number +> : any +>await 42 : 42 +>42 : 42 +} + +async function bar2() { +>bar2 : () => Promise + + --await 42; // Error +>-- : number +> : any +>await 42 : 42 +>42 : 42 +} + +async function bar3() { +>bar3 : () => Promise + + var x = 42; +>x : number +>42 : 42 + + await x++; // OK but shouldn't need parenthesis +>await x++ : number +>x++ : number +>x : number +} + +async function bar4() { +>bar4 : () => Promise + + var x = 42; +>x : number +>42 : 42 + + await x--; // OK but shouldn't need parenthesis +>await x-- : number +>x-- : number +>x : number +} diff --git a/tests/baselines/reference/badArrayIndex.symbols b/tests/baselines/reference/badArrayIndex.symbols new file mode 100644 index 00000000000..3ea300fca50 --- /dev/null +++ b/tests/baselines/reference/badArrayIndex.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/badArrayIndex.ts === +var results = number[]; +>results : Symbol(results, Decl(badArrayIndex.ts, 0, 3)) + diff --git a/tests/baselines/reference/badArrayIndex.types b/tests/baselines/reference/badArrayIndex.types new file mode 100644 index 00000000000..a8b541124b6 --- /dev/null +++ b/tests/baselines/reference/badArrayIndex.types @@ -0,0 +1,6 @@ +=== tests/cases/compiler/badArrayIndex.ts === +var results = number[]; +>results : any +>number[] : any +>number : any + diff --git a/tests/baselines/reference/badArraySyntax.symbols b/tests/baselines/reference/badArraySyntax.symbols new file mode 100644 index 00000000000..7b8f96124b0 --- /dev/null +++ b/tests/baselines/reference/badArraySyntax.symbols @@ -0,0 +1,35 @@ +=== tests/cases/compiler/badArraySyntax.ts === +class Z { +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) + + public x = ""; +>x : Symbol(Z.x, Decl(badArraySyntax.ts, 0, 9)) +} + +var a1: Z[] = []; +>a1 : Symbol(a1, Decl(badArraySyntax.ts, 4, 3)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) + +var a2 = new Z[]; +>a2 : Symbol(a2, Decl(badArraySyntax.ts, 5, 3)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) + +var a3 = new Z[](); +>a3 : Symbol(a3, Decl(badArraySyntax.ts, 6, 3)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) + +var a4: Z[] = new Z[]; +>a4 : Symbol(a4, Decl(badArraySyntax.ts, 7, 3)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) + +var a5: Z[] = new Z[](); +>a5 : Symbol(a5, Decl(badArraySyntax.ts, 8, 3)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) + +var a6: Z[][] = new Z [ ] [ ]; +>a6 : Symbol(a6, Decl(badArraySyntax.ts, 9, 3)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) +>Z : Symbol(Z, Decl(badArraySyntax.ts, 0, 0)) + diff --git a/tests/baselines/reference/badArraySyntax.types b/tests/baselines/reference/badArraySyntax.types new file mode 100644 index 00000000000..f7982034d71 --- /dev/null +++ b/tests/baselines/reference/badArraySyntax.types @@ -0,0 +1,48 @@ +=== tests/cases/compiler/badArraySyntax.ts === +class Z { +>Z : Z + + public x = ""; +>x : string +>"" : "" +} + +var a1: Z[] = []; +>a1 : Z[] +>Z : Z +>[] : undefined[] + +var a2 = new Z[]; +>a2 : any +>new Z[] : any +>Z[] : any +>Z : typeof Z + +var a3 = new Z[](); +>a3 : any +>new Z[]() : any +>Z[] : any +>Z : typeof Z + +var a4: Z[] = new Z[]; +>a4 : Z[] +>Z : Z +>new Z[] : any +>Z[] : any +>Z : typeof Z + +var a5: Z[] = new Z[](); +>a5 : Z[] +>Z : Z +>new Z[]() : any +>Z[] : any +>Z : typeof Z + +var a6: Z[][] = new Z [ ] [ ]; +>a6 : Z[][] +>Z : Z +>new Z [ ] [ ] : any +>Z [ ] [ ] : any +>Z [ ] : any +>Z : typeof Z + diff --git a/tests/baselines/reference/badExternalModuleReference.symbols b/tests/baselines/reference/badExternalModuleReference.symbols new file mode 100644 index 00000000000..3e6d6a80e84 --- /dev/null +++ b/tests/baselines/reference/badExternalModuleReference.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/badExternalModuleReference.ts === +import a1 = require("garbage"); +>a1 : Symbol(a1, Decl(badExternalModuleReference.ts, 0, 0)) + +export declare var a: { +>a : Symbol(a, Decl(badExternalModuleReference.ts, 1, 18)) + + test1: a1.connectModule; +>test1 : Symbol(test1, Decl(badExternalModuleReference.ts, 1, 23)) +>a1 : Symbol(a1, Decl(badExternalModuleReference.ts, 0, 0)) +>connectModule : Symbol(a1) + + (): a1.connectExport; +>a1 : Symbol(a1, Decl(badExternalModuleReference.ts, 0, 0)) +>connectExport : Symbol(a1) + +}; + diff --git a/tests/baselines/reference/badExternalModuleReference.types b/tests/baselines/reference/badExternalModuleReference.types new file mode 100644 index 00000000000..61314d8abb8 --- /dev/null +++ b/tests/baselines/reference/badExternalModuleReference.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/badExternalModuleReference.ts === +import a1 = require("garbage"); +>a1 : any + +export declare var a: { +>a : { (): any; test1: any; } + + test1: a1.connectModule; +>test1 : any +>a1 : any +>connectModule : any + + (): a1.connectExport; +>a1 : any +>connectExport : any + +}; + diff --git a/tests/baselines/reference/baseCheck.symbols b/tests/baselines/reference/baseCheck.symbols new file mode 100644 index 00000000000..3fe3616009c --- /dev/null +++ b/tests/baselines/reference/baseCheck.symbols @@ -0,0 +1,75 @@ +=== tests/cases/compiler/baseCheck.ts === +class C { constructor(x: number, y: number) { } } +>C : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>x : Symbol(x, Decl(baseCheck.ts, 0, 22)) +>y : Symbol(y, Decl(baseCheck.ts, 0, 32)) + +class ELoc extends C { +>ELoc : Symbol(ELoc, Decl(baseCheck.ts, 0, 49)) +>C : Symbol(C, Decl(baseCheck.ts, 0, 0)) + + constructor(x: number) { +>x : Symbol(x, Decl(baseCheck.ts, 2, 16)) + + super(0, x); +>super : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>x : Symbol(x, Decl(baseCheck.ts, 2, 16)) + } +} +class ELocVar extends C { +>ELocVar : Symbol(ELocVar, Decl(baseCheck.ts, 5, 1)) +>C : Symbol(C, Decl(baseCheck.ts, 0, 0)) + + constructor(x: number) { +>x : Symbol(x, Decl(baseCheck.ts, 7, 16)) + + super(0, loc); +>super : Symbol(C, Decl(baseCheck.ts, 0, 0)) + } + + m() { +>m : Symbol(ELocVar.m, Decl(baseCheck.ts, 9, 5)) + + var loc=10; +>loc : Symbol(loc, Decl(baseCheck.ts, 12, 11)) + } +} + +class D extends C { constructor(public z: number) { super(this.z) } } // too few params +>D : Symbol(D, Decl(baseCheck.ts, 14, 1)) +>C : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>z : Symbol(D.z, Decl(baseCheck.ts, 16, 32)) +>super : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>this.z : Symbol(D.z, Decl(baseCheck.ts, 16, 32)) +>this : Symbol(D, Decl(baseCheck.ts, 14, 1)) +>z : Symbol(D.z, Decl(baseCheck.ts, 16, 32)) + +class E extends C { constructor(public z: number) { super(0, this.z) } } +>E : Symbol(E, Decl(baseCheck.ts, 16, 70)) +>C : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>z : Symbol(E.z, Decl(baseCheck.ts, 17, 32)) +>super : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>this.z : Symbol(E.z, Decl(baseCheck.ts, 17, 32)) +>this : Symbol(E, Decl(baseCheck.ts, 16, 70)) +>z : Symbol(E.z, Decl(baseCheck.ts, 17, 32)) + +class F extends C { constructor(public z: number) { super("hello", this.z) } } // first param type +>F : Symbol(F, Decl(baseCheck.ts, 17, 72)) +>C : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>z : Symbol(F.z, Decl(baseCheck.ts, 18, 32)) +>super : Symbol(C, Decl(baseCheck.ts, 0, 0)) +>this.z : Symbol(F.z, Decl(baseCheck.ts, 18, 32)) +>this : Symbol(F, Decl(baseCheck.ts, 17, 72)) +>z : Symbol(F.z, Decl(baseCheck.ts, 18, 32)) + +function f() { +>f : Symbol(f, Decl(baseCheck.ts, 18, 78)) + + if (x<10) { + x=11; + } + else { + x=12; + } +} + diff --git a/tests/baselines/reference/baseCheck.types b/tests/baselines/reference/baseCheck.types new file mode 100644 index 00000000000..a5e3976d0ea --- /dev/null +++ b/tests/baselines/reference/baseCheck.types @@ -0,0 +1,96 @@ +=== tests/cases/compiler/baseCheck.ts === +class C { constructor(x: number, y: number) { } } +>C : C +>x : number +>y : number + +class ELoc extends C { +>ELoc : ELoc +>C : C + + constructor(x: number) { +>x : number + + super(0, x); +>super(0, x) : void +>super : typeof C +>0 : 0 +>x : number + } +} +class ELocVar extends C { +>ELocVar : ELocVar +>C : C + + constructor(x: number) { +>x : number + + super(0, loc); +>super(0, loc) : void +>super : typeof C +>0 : 0 +>loc : any + } + + m() { +>m : () => void + + var loc=10; +>loc : number +>10 : 10 + } +} + +class D extends C { constructor(public z: number) { super(this.z) } } // too few params +>D : D +>C : C +>z : number +>super(this.z) : void +>super : typeof C +>this.z : number +>this : this +>z : number + +class E extends C { constructor(public z: number) { super(0, this.z) } } +>E : E +>C : C +>z : number +>super(0, this.z) : void +>super : typeof C +>0 : 0 +>this.z : number +>this : this +>z : number + +class F extends C { constructor(public z: number) { super("hello", this.z) } } // first param type +>F : F +>C : C +>z : number +>super("hello", this.z) : void +>super : typeof C +>"hello" : "hello" +>this.z : number +>this : this +>z : number + +function f() { +>f : () => void + + if (x<10) { +>x<10 : boolean +>x : any +>10 : 10 + + x=11; +>x=11 : 11 +>x : any +>11 : 11 + } + else { + x=12; +>x=12 : 12 +>x : any +>12 : 12 + } +} + diff --git a/tests/baselines/reference/baseConstraintOfDecorator.symbols b/tests/baselines/reference/baseConstraintOfDecorator.symbols new file mode 100644 index 00000000000..71d7773a7cf --- /dev/null +++ b/tests/baselines/reference/baseConstraintOfDecorator.symbols @@ -0,0 +1,29 @@ +=== tests/cases/compiler/baseConstraintOfDecorator.ts === +export function classExtender(superClass: TFunction, _instanceModifier: (instance: any, args: any[]) => void): TFunction { +>classExtender : Symbol(classExtender, Decl(baseConstraintOfDecorator.ts, 0, 0)) +>TFunction : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 0, 30)) +>superClass : Symbol(superClass, Decl(baseConstraintOfDecorator.ts, 0, 41)) +>TFunction : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 0, 30)) +>_instanceModifier : Symbol(_instanceModifier, Decl(baseConstraintOfDecorator.ts, 0, 63)) +>instance : Symbol(instance, Decl(baseConstraintOfDecorator.ts, 0, 84)) +>args : Symbol(args, Decl(baseConstraintOfDecorator.ts, 0, 98)) +>TFunction : Symbol(TFunction, Decl(baseConstraintOfDecorator.ts, 0, 30)) + + return class decoratorFunc extends superClass { +>decoratorFunc : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 1, 10)) +>superClass : Symbol(superClass, Decl(baseConstraintOfDecorator.ts, 0, 41)) + + constructor(...args: any[]) { +>args : Symbol(args, Decl(baseConstraintOfDecorator.ts, 2, 20)) + + super(...args); +>args : Symbol(args, Decl(baseConstraintOfDecorator.ts, 2, 20)) + + _instanceModifier(this, args); +>_instanceModifier : Symbol(_instanceModifier, Decl(baseConstraintOfDecorator.ts, 0, 63)) +>this : Symbol(decoratorFunc, Decl(baseConstraintOfDecorator.ts, 1, 10)) +>args : Symbol(args, Decl(baseConstraintOfDecorator.ts, 2, 20)) + } + }; +} + diff --git a/tests/baselines/reference/baseConstraintOfDecorator.types b/tests/baselines/reference/baseConstraintOfDecorator.types new file mode 100644 index 00000000000..f1af8a8d503 --- /dev/null +++ b/tests/baselines/reference/baseConstraintOfDecorator.types @@ -0,0 +1,34 @@ +=== tests/cases/compiler/baseConstraintOfDecorator.ts === +export function classExtender(superClass: TFunction, _instanceModifier: (instance: any, args: any[]) => void): TFunction { +>classExtender : (superClass: TFunction, _instanceModifier: (instance: any, args: any[]) => void) => TFunction +>TFunction : TFunction +>superClass : TFunction +>TFunction : TFunction +>_instanceModifier : (instance: any, args: any[]) => void +>instance : any +>args : any[] +>TFunction : TFunction + + return class decoratorFunc extends superClass { +>class decoratorFunc extends superClass { constructor(...args: any[]) { super(...args); _instanceModifier(this, args); } } : typeof decoratorFunc +>decoratorFunc : typeof decoratorFunc +>superClass : TFunction + + constructor(...args: any[]) { +>args : any[] + + super(...args); +>super(...args) : void +>super : any +>...args : any +>args : any[] + + _instanceModifier(this, args); +>_instanceModifier(this, args) : void +>_instanceModifier : (instance: any, args: any[]) => void +>this : this +>args : any[] + } + }; +} + diff --git a/tests/baselines/reference/baseExpressionTypeParameters.symbols b/tests/baselines/reference/baseExpressionTypeParameters.symbols new file mode 100644 index 00000000000..22f716a0a1c --- /dev/null +++ b/tests/baselines/reference/baseExpressionTypeParameters.symbols @@ -0,0 +1,32 @@ +=== tests/cases/compiler/baseExpressionTypeParameters.ts === +// Repro from #17829 + +function base() { +>base : Symbol(base, Decl(baseExpressionTypeParameters.ts, 0, 0)) +>T : Symbol(T, Decl(baseExpressionTypeParameters.ts, 2, 14)) + + class Base { +>Base : Symbol(Base, Decl(baseExpressionTypeParameters.ts, 2, 20)) + + static prop: T; +>prop : Symbol(Base.prop, Decl(baseExpressionTypeParameters.ts, 3, 16)) +>T : Symbol(T, Decl(baseExpressionTypeParameters.ts, 2, 14)) + } + return Base; +>Base : Symbol(Base, Decl(baseExpressionTypeParameters.ts, 2, 20)) +} + +class Gen extends base() {} // Error, T not in scope +>Gen : Symbol(Gen, Decl(baseExpressionTypeParameters.ts, 7, 1)) +>T : Symbol(T, Decl(baseExpressionTypeParameters.ts, 9, 10)) +>base : Symbol(base, Decl(baseExpressionTypeParameters.ts, 0, 0)) + +class Spec extends Gen {} +>Spec : Symbol(Spec, Decl(baseExpressionTypeParameters.ts, 9, 33)) +>Gen : Symbol(Gen, Decl(baseExpressionTypeParameters.ts, 7, 1)) + +Spec.prop; +>Spec.prop : Symbol(Base.prop, Decl(baseExpressionTypeParameters.ts, 3, 16)) +>Spec : Symbol(Spec, Decl(baseExpressionTypeParameters.ts, 9, 33)) +>prop : Symbol(Base.prop, Decl(baseExpressionTypeParameters.ts, 3, 16)) + diff --git a/tests/baselines/reference/baseExpressionTypeParameters.types b/tests/baselines/reference/baseExpressionTypeParameters.types new file mode 100644 index 00000000000..252d39e5e36 --- /dev/null +++ b/tests/baselines/reference/baseExpressionTypeParameters.types @@ -0,0 +1,35 @@ +=== tests/cases/compiler/baseExpressionTypeParameters.ts === +// Repro from #17829 + +function base() { +>base : () => typeof Base +>T : T + + class Base { +>Base : Base + + static prop: T; +>prop : T +>T : T + } + return Base; +>Base : typeof Base +} + +class Gen extends base() {} // Error, T not in scope +>Gen : Gen +>T : T +>base() : base.Base +>base : () => typeof Base +>T : No type information available! + +class Spec extends Gen {} +>Spec : Spec +>Gen : Gen + +Spec.prop; +>Spec.prop : string +>Spec.prop : any +>Spec : typeof Spec +>prop : any + diff --git a/tests/baselines/reference/baseTypePrivateMemberClash.symbols b/tests/baselines/reference/baseTypePrivateMemberClash.symbols new file mode 100644 index 00000000000..ede8869f96f --- /dev/null +++ b/tests/baselines/reference/baseTypePrivateMemberClash.symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/baseTypePrivateMemberClash.ts === +class X { +>X : Symbol(X, Decl(baseTypePrivateMemberClash.ts, 0, 0)) + + private m: number; +>m : Symbol(X.m, Decl(baseTypePrivateMemberClash.ts, 0, 9)) +} +class Y { +>Y : Symbol(Y, Decl(baseTypePrivateMemberClash.ts, 2, 1)) + + private m: string; +>m : Symbol(Y.m, Decl(baseTypePrivateMemberClash.ts, 3, 9)) +} + +interface Z extends X, Y { } +>Z : Symbol(Z, Decl(baseTypePrivateMemberClash.ts, 5, 1)) +>X : Symbol(X, Decl(baseTypePrivateMemberClash.ts, 0, 0)) +>Y : Symbol(Y, Decl(baseTypePrivateMemberClash.ts, 2, 1)) + diff --git a/tests/baselines/reference/baseTypePrivateMemberClash.types b/tests/baselines/reference/baseTypePrivateMemberClash.types new file mode 100644 index 00000000000..6cd8b89628a --- /dev/null +++ b/tests/baselines/reference/baseTypePrivateMemberClash.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/baseTypePrivateMemberClash.ts === +class X { +>X : X + + private m: number; +>m : number +} +class Y { +>Y : Y + + private m: string; +>m : string +} + +interface Z extends X, Y { } +>Z : Z +>X : X +>Y : Y + diff --git a/tests/baselines/reference/bases.symbols b/tests/baselines/reference/bases.symbols new file mode 100644 index 00000000000..204205e20e8 --- /dev/null +++ b/tests/baselines/reference/bases.symbols @@ -0,0 +1,35 @@ +=== tests/cases/compiler/bases.ts === +interface I { +>I : Symbol(I, Decl(bases.ts, 0, 0)) + + x; +>x : Symbol(I.x, Decl(bases.ts, 0, 13)) +} + +class B { +>B : Symbol(B, Decl(bases.ts, 2, 1)) + + constructor() { + this.y: any; +>this : Symbol(B, Decl(bases.ts, 2, 1)) + } +} + +class C extends B implements I { +>C : Symbol(C, Decl(bases.ts, 8, 1)) +>B : Symbol(B, Decl(bases.ts, 2, 1)) +>I : Symbol(I, Decl(bases.ts, 0, 0)) + + constructor() { + this.x: any; +>this : Symbol(C, Decl(bases.ts, 8, 1)) + } +} + +new C().x; +>C : Symbol(C, Decl(bases.ts, 8, 1)) + +new C().y; +>C : Symbol(C, Decl(bases.ts, 8, 1)) + + diff --git a/tests/baselines/reference/bases.types b/tests/baselines/reference/bases.types new file mode 100644 index 00000000000..46a641a1881 --- /dev/null +++ b/tests/baselines/reference/bases.types @@ -0,0 +1,47 @@ +=== tests/cases/compiler/bases.ts === +interface I { +>I : I + + x; +>x : any +} + +class B { +>B : B + + constructor() { + this.y: any; +>this.y : any +>this : this +>y : any +>any : any + } +} + +class C extends B implements I { +>C : C +>B : B +>I : I + + constructor() { + this.x: any; +>this.x : any +>this : this +>x : any +>any : any + } +} + +new C().x; +>new C().x : any +>new C() : C +>C : typeof C +>x : any + +new C().y; +>new C().y : any +>new C() : C +>C : typeof C +>y : any + + diff --git a/tests/baselines/reference/binaryArithmatic3.symbols b/tests/baselines/reference/binaryArithmatic3.symbols new file mode 100644 index 00000000000..66ca1a70b75 --- /dev/null +++ b/tests/baselines/reference/binaryArithmatic3.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/binaryArithmatic3.ts === +var v = undefined | undefined; +>v : Symbol(v, Decl(binaryArithmatic3.ts, 0, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + diff --git a/tests/baselines/reference/binaryArithmatic3.types b/tests/baselines/reference/binaryArithmatic3.types new file mode 100644 index 00000000000..2cb7161fd14 --- /dev/null +++ b/tests/baselines/reference/binaryArithmatic3.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/binaryArithmatic3.ts === +var v = undefined | undefined; +>v : number +>undefined | undefined : number +>undefined : undefined +>undefined : undefined + diff --git a/tests/baselines/reference/binaryArithmatic4.symbols b/tests/baselines/reference/binaryArithmatic4.symbols new file mode 100644 index 00000000000..4dab72c58d1 --- /dev/null +++ b/tests/baselines/reference/binaryArithmatic4.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/binaryArithmatic4.ts === +var v = null | null; +>v : Symbol(v, Decl(binaryArithmatic4.ts, 0, 3)) + diff --git a/tests/baselines/reference/binaryArithmatic4.types b/tests/baselines/reference/binaryArithmatic4.types new file mode 100644 index 00000000000..c876d76e1c4 --- /dev/null +++ b/tests/baselines/reference/binaryArithmatic4.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/binaryArithmatic4.ts === +var v = null | null; +>v : number +>null | null : number +>null : null +>null : null + diff --git a/tests/baselines/reference/binaryIntegerLiteralError.symbols b/tests/baselines/reference/binaryIntegerLiteralError.symbols new file mode 100644 index 00000000000..bd40cecff8d --- /dev/null +++ b/tests/baselines/reference/binaryIntegerLiteralError.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/es6/binaryAndOctalIntegerLiteral/binaryIntegerLiteralError.ts === +// error +var bin1 = 0B1102110; +>bin1 : Symbol(bin1, Decl(binaryIntegerLiteralError.ts, 1, 3), Decl(binaryIntegerLiteralError.ts, 2, 3)) + +var bin1 = 0b11023410; +>bin1 : Symbol(bin1, Decl(binaryIntegerLiteralError.ts, 1, 3), Decl(binaryIntegerLiteralError.ts, 2, 3)) + +var obj1 = { +>obj1 : Symbol(obj1, Decl(binaryIntegerLiteralError.ts, 4, 3)) + + 0b11010: "hi", + 26: "Hello", + "26": "world", +}; + diff --git a/tests/baselines/reference/binaryIntegerLiteralError.types b/tests/baselines/reference/binaryIntegerLiteralError.types new file mode 100644 index 00000000000..5ab51f74666 --- /dev/null +++ b/tests/baselines/reference/binaryIntegerLiteralError.types @@ -0,0 +1,27 @@ +=== tests/cases/conformance/es6/binaryAndOctalIntegerLiteral/binaryIntegerLiteralError.ts === +// error +var bin1 = 0B1102110; +>bin1 : number +>0B110 : 6 +>2110 : 2110 + +var bin1 = 0b11023410; +>bin1 : number +>0b110 : 6 +>23410 : 23410 + +var obj1 = { +>obj1 : { 0b11010: string; } +>{ 0b11010: "hi", 26: "Hello", "26": "world",} : { 0b11010: string; } + + 0b11010: "hi", +>"hi" : "hi" + + 26: "Hello", +>"Hello" : "Hello" + + "26": "world", +>"world" : "world" + +}; + diff --git a/tests/baselines/reference/bind1.symbols b/tests/baselines/reference/bind1.symbols new file mode 100644 index 00000000000..c985a283932 --- /dev/null +++ b/tests/baselines/reference/bind1.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/bind1.ts === +module M { +>M : Symbol(M, Decl(bind1.ts, 0, 0)) + + export class C implements I {} // this should be an unresolved symbol I error +>C : Symbol(C, Decl(bind1.ts, 0, 10)) +} + + diff --git a/tests/baselines/reference/bind1.types b/tests/baselines/reference/bind1.types new file mode 100644 index 00000000000..7502febacca --- /dev/null +++ b/tests/baselines/reference/bind1.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/bind1.ts === +module M { +>M : typeof M + + export class C implements I {} // this should be an unresolved symbol I error +>C : C +>I : No type information available! +} + + diff --git a/tests/baselines/reference/bindingPatternInParameter01.symbols b/tests/baselines/reference/bindingPatternInParameter01.symbols new file mode 100644 index 00000000000..466c7a0bc70 --- /dev/null +++ b/tests/baselines/reference/bindingPatternInParameter01.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/bindingPatternInParameter01.ts === +const nestedArray = [[[1, 2]], [[3, 4]]]; +>nestedArray : Symbol(nestedArray, Decl(bindingPatternInParameter01.ts, 0, 5)) + +nestedArray.forEach(([[a, b]]) => { +>nestedArray.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>nestedArray : Symbol(nestedArray, Decl(bindingPatternInParameter01.ts, 0, 5)) +>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>a : Symbol(a, Decl(bindingPatternInParameter01.ts, 2, 23)) +>b : Symbol(b, Decl(bindingPatternInParameter01.ts, 2, 25)) + + console.log(a, b); +>a : Symbol(a, Decl(bindingPatternInParameter01.ts, 2, 23)) +>b : Symbol(b, Decl(bindingPatternInParameter01.ts, 2, 25)) + +}); + diff --git a/tests/baselines/reference/bindingPatternInParameter01.types b/tests/baselines/reference/bindingPatternInParameter01.types new file mode 100644 index 00000000000..927deae8c07 --- /dev/null +++ b/tests/baselines/reference/bindingPatternInParameter01.types @@ -0,0 +1,32 @@ +=== tests/cases/compiler/bindingPatternInParameter01.ts === +const nestedArray = [[[1, 2]], [[3, 4]]]; +>nestedArray : number[][][] +>[[[1, 2]], [[3, 4]]] : number[][][] +>[[1, 2]] : number[][] +>[1, 2] : number[] +>1 : 1 +>2 : 2 +>[[3, 4]] : number[][] +>[3, 4] : number[] +>3 : 3 +>4 : 4 + +nestedArray.forEach(([[a, b]]) => { +>nestedArray.forEach(([[a, b]]) => { console.log(a, b);}) : void +>nestedArray.forEach : (callbackfn: (value: number[][], index: number, array: number[][][]) => void, thisArg?: any) => void +>nestedArray : number[][][] +>forEach : (callbackfn: (value: number[][], index: number, array: number[][][]) => void, thisArg?: any) => void +>([[a, b]]) => { console.log(a, b);} : ([[a, b]]: number[][]) => void +>a : number +>b : number + + console.log(a, b); +>console.log(a, b) : any +>console.log : any +>console : any +>log : any +>a : number +>b : number + +}); + diff --git a/tests/baselines/reference/bitwiseCompoundAssignmentOperators.symbols b/tests/baselines/reference/bitwiseCompoundAssignmentOperators.symbols new file mode 100644 index 00000000000..87a24424787 --- /dev/null +++ b/tests/baselines/reference/bitwiseCompoundAssignmentOperators.symbols @@ -0,0 +1,98 @@ +=== tests/cases/compiler/bitwiseCompoundAssignmentOperators.ts === +var a = true; +>a : Symbol(a, Decl(bitwiseCompoundAssignmentOperators.ts, 0, 3)) + +var b = 1; +>b : Symbol(b, Decl(bitwiseCompoundAssignmentOperators.ts, 1, 3)) + +a ^= a; +>a : Symbol(a, Decl(bitwiseCompoundAssignmentOperators.ts, 0, 3)) +>a : Symbol(a, Decl(bitwiseCompoundAssignmentOperators.ts, 0, 3)) + +a = true; +>a : Symbol(a, Decl(bitwiseCompoundAssignmentOperators.ts, 0, 3)) + +b ^= b; +>b : Symbol(b, Decl(bitwiseCompoundAssignmentOperators.ts, 1, 3)) +>b : Symbol(b, Decl(bitwiseCompoundAssignmentOperators.ts, 1, 3)) + +b = 1; +>b : Symbol(b, Decl(bitwiseCompoundAssignmentOperators.ts, 1, 3)) + +a ^= b; +>a : Symbol(a, Decl(bitwiseCompoundAssignmentOperators.ts, 0, 3)) +>b : Symbol(b, Decl(bitwiseCompoundAssignmentOperators.ts, 1, 3)) + +a = true; +>a : Symbol(a, Decl(bitwiseCompoundAssignmentOperators.ts, 0, 3)) + +b ^= a; +>b : Symbol(b, Decl(bitwiseCompoundAssignmentOperators.ts, 1, 3)) +>a : Symbol(a, Decl(bitwiseCompoundAssignmentOperators.ts, 0, 3)) + +b = 1; +>b : Symbol(b, Decl(bitwiseCompoundAssignmentOperators.ts, 1, 3)) + +var c = false; +>c : Symbol(c, Decl(bitwiseCompoundAssignmentOperators.ts, 11, 3)) + +var d = 2; +>d : Symbol(d, Decl(bitwiseCompoundAssignmentOperators.ts, 12, 3)) + +c &= c; +>c : Symbol(c, Decl(bitwiseCompoundAssignmentOperators.ts, 11, 3)) +>c : Symbol(c, Decl(bitwiseCompoundAssignmentOperators.ts, 11, 3)) + +c = false; +>c : Symbol(c, Decl(bitwiseCompoundAssignmentOperators.ts, 11, 3)) + +d &= d; +>d : Symbol(d, Decl(bitwiseCompoundAssignmentOperators.ts, 12, 3)) +>d : Symbol(d, Decl(bitwiseCompoundAssignmentOperators.ts, 12, 3)) + +d = 2; +>d : Symbol(d, Decl(bitwiseCompoundAssignmentOperators.ts, 12, 3)) + +c &= d; +>c : Symbol(c, Decl(bitwiseCompoundAssignmentOperators.ts, 11, 3)) +>d : Symbol(d, Decl(bitwiseCompoundAssignmentOperators.ts, 12, 3)) + +c = false; +>c : Symbol(c, Decl(bitwiseCompoundAssignmentOperators.ts, 11, 3)) + +d &= c; +>d : Symbol(d, Decl(bitwiseCompoundAssignmentOperators.ts, 12, 3)) +>c : Symbol(c, Decl(bitwiseCompoundAssignmentOperators.ts, 11, 3)) + +var e = true; +>e : Symbol(e, Decl(bitwiseCompoundAssignmentOperators.ts, 21, 3)) + +var f = 0; +>f : Symbol(f, Decl(bitwiseCompoundAssignmentOperators.ts, 22, 3)) + +e |= e; +>e : Symbol(e, Decl(bitwiseCompoundAssignmentOperators.ts, 21, 3)) +>e : Symbol(e, Decl(bitwiseCompoundAssignmentOperators.ts, 21, 3)) + +e = true; +>e : Symbol(e, Decl(bitwiseCompoundAssignmentOperators.ts, 21, 3)) + +f |= f; +>f : Symbol(f, Decl(bitwiseCompoundAssignmentOperators.ts, 22, 3)) +>f : Symbol(f, Decl(bitwiseCompoundAssignmentOperators.ts, 22, 3)) + +f = 0; +>f : Symbol(f, Decl(bitwiseCompoundAssignmentOperators.ts, 22, 3)) + +e |= f; +>e : Symbol(e, Decl(bitwiseCompoundAssignmentOperators.ts, 21, 3)) +>f : Symbol(f, Decl(bitwiseCompoundAssignmentOperators.ts, 22, 3)) + +e = true; +>e : Symbol(e, Decl(bitwiseCompoundAssignmentOperators.ts, 21, 3)) + +f |= f; +>f : Symbol(f, Decl(bitwiseCompoundAssignmentOperators.ts, 22, 3)) +>f : Symbol(f, Decl(bitwiseCompoundAssignmentOperators.ts, 22, 3)) + + diff --git a/tests/baselines/reference/bitwiseCompoundAssignmentOperators.types b/tests/baselines/reference/bitwiseCompoundAssignmentOperators.types new file mode 100644 index 00000000000..dd71bb1e6c2 --- /dev/null +++ b/tests/baselines/reference/bitwiseCompoundAssignmentOperators.types @@ -0,0 +1,136 @@ +=== tests/cases/compiler/bitwiseCompoundAssignmentOperators.ts === +var a = true; +>a : boolean +>true : true + +var b = 1; +>b : number +>1 : 1 + +a ^= a; +>a ^= a : number +>a : boolean +>a : true + +a = true; +>a = true : true +>a : boolean +>true : true + +b ^= b; +>b ^= b : number +>b : number +>b : number + +b = 1; +>b = 1 : 1 +>b : number +>1 : 1 + +a ^= b; +>a ^= b : number +>a : boolean +>b : number + +a = true; +>a = true : true +>a : boolean +>true : true + +b ^= a; +>b ^= a : number +>b : number +>a : true + +b = 1; +>b = 1 : 1 +>b : number +>1 : 1 + +var c = false; +>c : boolean +>false : false + +var d = 2; +>d : number +>2 : 2 + +c &= c; +>c &= c : number +>c : boolean +>c : false + +c = false; +>c = false : false +>c : boolean +>false : false + +d &= d; +>d &= d : number +>d : number +>d : number + +d = 2; +>d = 2 : 2 +>d : number +>2 : 2 + +c &= d; +>c &= d : number +>c : boolean +>d : number + +c = false; +>c = false : false +>c : boolean +>false : false + +d &= c; +>d &= c : number +>d : number +>c : false + +var e = true; +>e : boolean +>true : true + +var f = 0; +>f : number +>0 : 0 + +e |= e; +>e |= e : number +>e : boolean +>e : true + +e = true; +>e = true : true +>e : boolean +>true : true + +f |= f; +>f |= f : number +>f : number +>f : number + +f = 0; +>f = 0 : 0 +>f : number +>0 : 0 + +e |= f; +>e |= f : number +>e : boolean +>f : number + +e = true; +>e = true : true +>e : boolean +>true : true + +f |= f; +>f |= f : number +>f : number +>f : number + + diff --git a/tests/baselines/reference/bitwiseNotOperatorInvalidOperations.symbols b/tests/baselines/reference/bitwiseNotOperatorInvalidOperations.symbols new file mode 100644 index 00000000000..69965f071ca --- /dev/null +++ b/tests/baselines/reference/bitwiseNotOperatorInvalidOperations.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorInvalidOperations.ts === +// Unary operator ~ +var q; +>q : Symbol(q, Decl(bitwiseNotOperatorInvalidOperations.ts, 1, 3)) + +// operand before ~ +var a = q~; //expect error +>a : Symbol(a, Decl(bitwiseNotOperatorInvalidOperations.ts, 4, 3)) +>q : Symbol(q, Decl(bitwiseNotOperatorInvalidOperations.ts, 1, 3)) + +// multiple operands after ~ +var mul = ~[1, 2, "abc"], ""; //expect error +>mul : Symbol(mul, Decl(bitwiseNotOperatorInvalidOperations.ts, 7, 3)) + +// miss an operand +var b =~; +>b : Symbol(b, Decl(bitwiseNotOperatorInvalidOperations.ts, 10, 3)) + diff --git a/tests/baselines/reference/bitwiseNotOperatorInvalidOperations.types b/tests/baselines/reference/bitwiseNotOperatorInvalidOperations.types new file mode 100644 index 00000000000..01a51be84e9 --- /dev/null +++ b/tests/baselines/reference/bitwiseNotOperatorInvalidOperations.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorInvalidOperations.ts === +// Unary operator ~ +var q; +>q : any + +// operand before ~ +var a = q~; //expect error +>a : any +>q : any +>~ : number +> : any + +// multiple operands after ~ +var mul = ~[1, 2, "abc"], ""; //expect error +>mul : number +>~[1, 2, "abc"] : number +>[1, 2, "abc"] : (string | number)[] +>1 : 1 +>2 : 2 +>"abc" : "abc" +>"" : "" + +// miss an operand +var b =~; +>b : number +>~ : number +> : any + diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.symbols new file mode 100644 index 00000000000..c4ca5a5252b --- /dev/null +++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.symbols @@ -0,0 +1,188 @@ +=== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts === +// ~ operator on any type + +var ANY: any; +>ANY : Symbol(ANY, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 2, 3)) + +var ANY1; +>ANY1 : Symbol(ANY1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 3, 3)) + +var ANY2: any[] = ["", ""]; +>ANY2 : Symbol(ANY2, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 4, 3)) + +var obj: () => {} +>obj : Symbol(obj, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 5, 3)) + +var obj1 = { x:"", y: () => { }}; +>obj1 : Symbol(obj1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 12)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 18)) + +function foo(): any { +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 33)) + + var a; +>a : Symbol(a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 9, 7)) + + return a; +>a : Symbol(a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 9, 7)) +} +class A { +>A : Symbol(A, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 11, 1)) + + public a: any; +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 12, 9)) + + static foo() { +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 13, 18)) + + var a; +>a : Symbol(a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 15, 11)) + + return a; +>a : Symbol(a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 15, 11)) + } +} +module M { +>M : Symbol(M, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 18, 1)) + + export var n: any; +>n : Symbol(n, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 20, 14)) +} +var objA = new A(); +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 22, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 11, 1)) + +// any other type var +var ResultIsNumber = ~ANY1; +>ResultIsNumber : Symbol(ResultIsNumber, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 25, 3)) +>ANY1 : Symbol(ANY1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 3, 3)) + +var ResultIsNumber1 = ~ANY2; +>ResultIsNumber1 : Symbol(ResultIsNumber1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 26, 3)) +>ANY2 : Symbol(ANY2, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 4, 3)) + +var ResultIsNumber2 = ~A; +>ResultIsNumber2 : Symbol(ResultIsNumber2, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 27, 3)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 11, 1)) + +var ResultIsNumber3 = ~M; +>ResultIsNumber3 : Symbol(ResultIsNumber3, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 28, 3)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 18, 1)) + +var ResultIsNumber4 = ~obj; +>ResultIsNumber4 : Symbol(ResultIsNumber4, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 29, 3)) +>obj : Symbol(obj, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 5, 3)) + +var ResultIsNumber5 = ~obj1; +>ResultIsNumber5 : Symbol(ResultIsNumber5, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 30, 3)) +>obj1 : Symbol(obj1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 3)) + +// any type literal +var ResultIsNumber6 = ~undefined; +>ResultIsNumber6 : Symbol(ResultIsNumber6, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 33, 3)) +>undefined : Symbol(undefined) + +var ResultIsNumber7 = ~null; +>ResultIsNumber7 : Symbol(ResultIsNumber7, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 34, 3)) + +// any type expressions +var ResultIsNumber8 = ~ANY2[0] +>ResultIsNumber8 : Symbol(ResultIsNumber8, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 37, 3)) +>ANY2 : Symbol(ANY2, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 4, 3)) + +var ResultIsNumber9 = ~obj1.x; +>ResultIsNumber9 : Symbol(ResultIsNumber9, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 38, 3)) +>obj1.x : Symbol(x, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 12)) +>obj1 : Symbol(obj1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 12)) + +var ResultIsNumber10 = ~obj1.y; +>ResultIsNumber10 : Symbol(ResultIsNumber10, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 39, 3)) +>obj1.y : Symbol(y, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 18)) +>obj1 : Symbol(obj1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 3)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 18)) + +var ResultIsNumber11 = ~objA.a; +>ResultIsNumber11 : Symbol(ResultIsNumber11, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 40, 3)) +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 12, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 22, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 12, 9)) + +var ResultIsNumber12 = ~M.n; +>ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 41, 3)) +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 20, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 18, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 20, 14)) + +var ResultIsNumber13 = ~foo(); +>ResultIsNumber13 : Symbol(ResultIsNumber13, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 42, 3)) +>foo : Symbol(foo, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 33)) + +var ResultIsNumber14 = ~A.foo(); +>ResultIsNumber14 : Symbol(ResultIsNumber14, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 43, 3)) +>A.foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 13, 18)) +>A : Symbol(A, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 11, 1)) +>foo : Symbol(A.foo, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 13, 18)) + +var ResultIsNumber15 = ~(ANY + ANY1); +>ResultIsNumber15 : Symbol(ResultIsNumber15, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 44, 3)) +>ANY : Symbol(ANY, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 2, 3)) +>ANY1 : Symbol(ANY1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 3, 3)) + +var ResultIsNumber16 = ~(null + undefined); +>ResultIsNumber16 : Symbol(ResultIsNumber16, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 45, 3)) +>undefined : Symbol(undefined) + +var ResultIsNumber17 = ~(null + null); +>ResultIsNumber17 : Symbol(ResultIsNumber17, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 46, 3)) + +var ResultIsNumber18 = ~(undefined + undefined); +>ResultIsNumber18 : Symbol(ResultIsNumber18, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 47, 3)) +>undefined : Symbol(undefined) +>undefined : Symbol(undefined) + +// multiple ~ operators +var ResultIsNumber19 = ~~ANY; +>ResultIsNumber19 : Symbol(ResultIsNumber19, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 50, 3)) +>ANY : Symbol(ANY, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 2, 3)) + +var ResultIsNumber20 = ~~~(ANY + ANY1); +>ResultIsNumber20 : Symbol(ResultIsNumber20, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 51, 3)) +>ANY : Symbol(ANY, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 2, 3)) +>ANY1 : Symbol(ANY1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 3, 3)) + +//miss assignment operators +~ANY; +>ANY : Symbol(ANY, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 2, 3)) + +~ANY1; +>ANY1 : Symbol(ANY1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 3, 3)) + +~ANY2[0]; +>ANY2 : Symbol(ANY2, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 4, 3)) + +~ANY, ANY1; +>ANY : Symbol(ANY, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 2, 3)) +>ANY1 : Symbol(ANY1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 3, 3)) + +~obj1.y; +>obj1.y : Symbol(y, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 18)) +>obj1 : Symbol(obj1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 3)) +>y : Symbol(y, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 18)) + +~objA.a; +>objA.a : Symbol(A.a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 12, 9)) +>objA : Symbol(objA, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 22, 3)) +>a : Symbol(A.a, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 12, 9)) + +~M.n; +>M.n : Symbol(M.n, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 20, 14)) +>M : Symbol(M, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 18, 1)) +>n : Symbol(M.n, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 20, 14)) + +~~obj1.x; +>obj1.x : Symbol(x, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 12)) +>obj1 : Symbol(obj1, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 3)) +>x : Symbol(x, Decl(bitwiseNotOperatorWithAnyOtherType.ts, 6, 12)) + diff --git a/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.types b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.types new file mode 100644 index 00000000000..6f691ca92f5 --- /dev/null +++ b/tests/baselines/reference/bitwiseNotOperatorWithAnyOtherType.types @@ -0,0 +1,249 @@ +=== tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithAnyOtherType.ts === +// ~ operator on any type + +var ANY: any; +>ANY : any + +var ANY1; +>ANY1 : any + +var ANY2: any[] = ["", ""]; +>ANY2 : any[] +>["", ""] : string[] +>"" : "" +>"" : "" + +var obj: () => {} +>obj : () => {} + +var obj1 = { x:"", y: () => { }}; +>obj1 : { x: string; y: () => void; } +>{ x:"", y: () => { }} : { x: string; y: () => void; } +>x : string +>"" : "" +>y : () => void +>() => { } : () => void + +function foo(): any { +>foo : () => any + + var a; +>a : any + + return a; +>a : any +} +class A { +>A : A + + public a: any; +>a : any + + static foo() { +>foo : () => any + + var a; +>a : any + + return a; +>a : any + } +} +module M { +>M : typeof M + + export var n: any; +>n : any +} +var objA = new A(); +>objA : A +>new A() : A +>A : typeof A + +// any other type var +var ResultIsNumber = ~ANY1; +>ResultIsNumber : number +>~ANY1 : number +>ANY1 : any + +var ResultIsNumber1 = ~ANY2; +>ResultIsNumber1 : number +>~ANY2 : number +>ANY2 : any[] + +var ResultIsNumber2 = ~A; +>ResultIsNumber2 : number +>~A : number +>A : typeof A + +var ResultIsNumber3 = ~M; +>ResultIsNumber3 : number +>~M : number +>M : typeof M + +var ResultIsNumber4 = ~obj; +>ResultIsNumber4 : number +>~obj : number +>obj : () => {} + +var ResultIsNumber5 = ~obj1; +>ResultIsNumber5 : number +>~obj1 : number +>obj1 : { x: string; y: () => void; } + +// any type literal +var ResultIsNumber6 = ~undefined; +>ResultIsNumber6 : number +>~undefined : number +>undefined : undefined + +var ResultIsNumber7 = ~null; +>ResultIsNumber7 : number +>~null : number +>null : null + +// any type expressions +var ResultIsNumber8 = ~ANY2[0] +>ResultIsNumber8 : number +>~ANY2[0] : number +>ANY2[0] : any +>ANY2 : any[] +>0 : 0 + +var ResultIsNumber9 = ~obj1.x; +>ResultIsNumber9 : number +>~obj1.x : number +>obj1.x : string +>obj1 : { x: string; y: () => void; } +>x : string + +var ResultIsNumber10 = ~obj1.y; +>ResultIsNumber10 : number +>~obj1.y : number +>obj1.y : () => void +>obj1 : { x: string; y: () => void; } +>y : () => void + +var ResultIsNumber11 = ~objA.a; +>ResultIsNumber11 : number +>~objA.a : number +>objA.a : any +>objA : A +>a : any + +var ResultIsNumber12 = ~M.n; +>ResultIsNumber12 : number +>~M.n : number +>M.n : any +>M : typeof M +>n : any + +var ResultIsNumber13 = ~foo(); +>ResultIsNumber13 : number +>~foo() : number +>foo() : any +>foo : () => any + +var ResultIsNumber14 = ~A.foo(); +>ResultIsNumber14 : number +>~A.foo() : number +>A.foo() : any +>A.foo : () => any +>A : typeof A +>foo : () => any + +var ResultIsNumber15 = ~(ANY + ANY1); +>ResultIsNumber15 : number +>~(ANY + ANY1) : number +>(ANY + ANY1) : any +>ANY + ANY1 : any +>ANY : any +>ANY1 : any + +var ResultIsNumber16 = ~(null + undefined); +>ResultIsNumber16 : number +>~(null + undefined) : number +>(null + undefined) : any +>null + undefined : any +>null : null +>undefined : undefined + +var ResultIsNumber17 = ~(null + null); +>ResultIsNumber17 : number +>~(null + null) : number +>(null + null) : any +>null + null : any +>null : null +>null : null + +var ResultIsNumber18 = ~(undefined + undefined); +>ResultIsNumber18 : number +>~(undefined + undefined) : number +>(undefined + undefined) : any +>undefined + undefined : any +>undefined : undefined +>undefined : undefined + +// multiple ~ operators +var ResultIsNumber19 = ~~ANY; +>ResultIsNumber19 : number +>~~ANY : number +>~ANY : number +>ANY : any + +var ResultIsNumber20 = ~~~(ANY + ANY1); +>ResultIsNumber20 : number +>~~~(ANY + ANY1) : number +>~~(ANY + ANY1) : number +>~(ANY + ANY1) : number +>(ANY + ANY1) : any +>ANY + ANY1 : any +>ANY : any +>ANY1 : any + +//miss assignment operators +~ANY; +>~ANY : number +>ANY : any + +~ANY1; +>~ANY1 : number +>ANY1 : any + +~ANY2[0]; +>~ANY2[0] : number +>ANY2[0] : any +>ANY2 : any[] +>0 : 0 + +~ANY, ANY1; +>~ANY, ANY1 : any +>~ANY : number +>ANY : any +>ANY1 : any + +~obj1.y; +>~obj1.y : number +>obj1.y : () => void +>obj1 : { x: string; y: () => void; } +>y : () => void + +~objA.a; +>~objA.a : number +>objA.a : any +>objA : A +>a : any + +~M.n; +>~M.n : number +>M.n : any +>M : typeof M +>n : any + +~~obj1.x; +>~~obj1.x : number +>~obj1.x : number +>obj1.x : string +>obj1 : { x: string; y: () => void; } +>x : string + diff --git a/tests/baselines/reference/blockScopedBindingUsedBeforeDef.symbols b/tests/baselines/reference/blockScopedBindingUsedBeforeDef.symbols new file mode 100644 index 00000000000..26c07aee531 --- /dev/null +++ b/tests/baselines/reference/blockScopedBindingUsedBeforeDef.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/blockScopedBindingUsedBeforeDef.ts === +// 1: +for (let {[a]: a} of [{ }]) continue; +>a : Symbol(a, Decl(blockScopedBindingUsedBeforeDef.ts, 1, 10)) +>a : Symbol(a, Decl(blockScopedBindingUsedBeforeDef.ts, 1, 10)) + +// 2: +for (let {[a]: a} = { }; false; ) continue; +>a : Symbol(a, Decl(blockScopedBindingUsedBeforeDef.ts, 4, 10)) +>a : Symbol(a, Decl(blockScopedBindingUsedBeforeDef.ts, 4, 10)) + +// 3: +let {[b]: b} = { }; +>b : Symbol(b, Decl(blockScopedBindingUsedBeforeDef.ts, 7, 5)) +>b : Symbol(b, Decl(blockScopedBindingUsedBeforeDef.ts, 7, 5)) + diff --git a/tests/baselines/reference/blockScopedBindingUsedBeforeDef.types b/tests/baselines/reference/blockScopedBindingUsedBeforeDef.types new file mode 100644 index 00000000000..9548aa7735d --- /dev/null +++ b/tests/baselines/reference/blockScopedBindingUsedBeforeDef.types @@ -0,0 +1,21 @@ +=== tests/cases/compiler/blockScopedBindingUsedBeforeDef.ts === +// 1: +for (let {[a]: a} of [{ }]) continue; +>a : any +>a : any +>[{ }] : {}[] +>{ } : {} + +// 2: +for (let {[a]: a} = { }; false; ) continue; +>a : any +>a : any +>{ } : {} +>false : false + +// 3: +let {[b]: b} = { }; +>b : any +>b : any +>{ } : {} + diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.symbols b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.symbols new file mode 100644 index 00000000000..f4358dc158a --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.symbols @@ -0,0 +1,17 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationInStrictClass.ts === +class c { +>c : Symbol(c, Decl(blockScopedFunctionDeclarationInStrictClass.ts, 0, 0)) + + method() { +>method : Symbol(c.method, Decl(blockScopedFunctionDeclarationInStrictClass.ts, 0, 9)) + + if (true) { + function foo() { } +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationInStrictClass.ts, 2, 19)) + + foo(); // ok +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationInStrictClass.ts, 2, 19)) + } + foo(); // not ok + } +} diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.types b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.types new file mode 100644 index 00000000000..4d16941aff0 --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictClass.types @@ -0,0 +1,22 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationInStrictClass.ts === +class c { +>c : c + + method() { +>method : () => void + + if (true) { +>true : true + + function foo() { } +>foo : () => void + + foo(); // ok +>foo() : void +>foo : () => void + } + foo(); // not ok +>foo() : any +>foo : any + } +} diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.symbols b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.symbols new file mode 100644 index 00000000000..95f22f59563 --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationInStrictModule.ts === +if (true) { + function foo() { } +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationInStrictModule.ts, 0, 11)) + + foo(); // ok +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationInStrictModule.ts, 0, 11)) +} + +export = foo; // not ok diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.types b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.types new file mode 100644 index 00000000000..f0b9693ed70 --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationInStrictModule.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationInStrictModule.ts === +if (true) { +>true : true + + function foo() { } +>foo : () => void + + foo(); // ok +>foo() : void +>foo : () => void +} + +export = foo; // not ok +>foo : No type information available! + diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.symbols b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.symbols new file mode 100644 index 00000000000..f72d7b2b5b8 --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationStrictES5.ts === +"use strict"; +if (true) { + function foo() { } // Error to declare function in block scope +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationStrictES5.ts, 1, 11)) + + foo(); // This call should be ok +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationStrictES5.ts, 1, 11)) +} +foo(); // Error to find name foo diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.types b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.types new file mode 100644 index 00000000000..1c87ccf9227 --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES5.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationStrictES5.ts === +"use strict"; +>"use strict" : "use strict" + +if (true) { +>true : true + + function foo() { } // Error to declare function in block scope +>foo : () => void + + foo(); // This call should be ok +>foo() : void +>foo : () => void +} +foo(); // Error to find name foo +>foo() : any +>foo : any + diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.symbols b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.symbols new file mode 100644 index 00000000000..fc8693231af --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.symbols @@ -0,0 +1,10 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationStrictES6.ts === +"use strict"; +if (true) { + function foo() { } // Allowed to declare block scope function +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationStrictES6.ts, 1, 11)) + + foo(); // This call should be ok +>foo : Symbol(foo, Decl(blockScopedFunctionDeclarationStrictES6.ts, 1, 11)) +} +foo(); // Cannot find name since foo is block scoped diff --git a/tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.types b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.types new file mode 100644 index 00000000000..174644fd610 --- /dev/null +++ b/tests/baselines/reference/blockScopedFunctionDeclarationStrictES6.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/blockScopedFunctionDeclarationStrictES6.ts === +"use strict"; +>"use strict" : "use strict" + +if (true) { +>true : true + + function foo() { } // Allowed to declare block scope function +>foo : () => void + + foo(); // This call should be ok +>foo() : void +>foo : () => void +} +foo(); // Cannot find name since foo is block scoped +>foo() : any +>foo : any + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.symbols b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.symbols new file mode 100644 index 00000000000..23df33b8ba4 --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationES5.ts === +function foo(a: number) { +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 0, 0)) +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 0, 13)) + + if (a === 1) { +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 0, 13)) + + function foo() { } // duplicate function +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) + + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) + } + else { + function foo() { } // duplicate function +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) + + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) + } + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 1, 18), Decl(blockScopedSameNameFunctionDeclarationES5.ts, 6, 10)) +} +foo(10); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 0, 0)) + +foo(); // not ok - needs number +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES5.ts, 0, 0)) + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.types b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.types new file mode 100644 index 00000000000..ca53002f949 --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES5.types @@ -0,0 +1,53 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationES5.ts === +function foo(a: number) { +>foo : (a: number) => void +>a : number + + if (a === 1) { +>a === 1 : boolean +>a : number +>1 : 1 + + function foo() { } // duplicate function +>foo : { (): void; (): void; } + + foo(); +>foo() : void +>foo : { (): void; (): void; } + + foo(10); // not ok +>foo(10) : any +>foo : { (): void; (): void; } +>10 : 10 + } + else { + function foo() { } // duplicate function +>foo : { (): void; (): void; } + + foo(); +>foo() : void +>foo : { (): void; (): void; } + + foo(10); // not ok +>foo(10) : any +>foo : { (): void; (): void; } +>10 : 10 + } + foo(10); // not ok +>foo(10) : any +>foo : { (): void; (): void; } +>10 : 10 + + foo(); +>foo() : void +>foo : { (): void; (): void; } +} +foo(10); +>foo(10) : void +>foo : (a: number) => void +>10 : 10 + +foo(); // not ok - needs number +>foo() : void +>foo : (a: number) => void + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.symbols b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.symbols new file mode 100644 index 00000000000..551d5dd413a --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationES6.ts === +function foo(a: number) { +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 0, 0)) +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 0, 13)) + + if (a === 10) { +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 0, 13)) + + function foo() { } // duplicate +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) + + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) + } + else { + function foo() { } // duplicate +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) + + foo(10);// not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) + } + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 1, 19), Decl(blockScopedSameNameFunctionDeclarationES6.ts, 6, 10)) +} +foo(10); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 0, 0)) + +foo(); // not ok - needs number +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationES6.ts, 0, 0)) + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.types b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.types new file mode 100644 index 00000000000..982ace6809c --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationES6.types @@ -0,0 +1,53 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationES6.ts === +function foo(a: number) { +>foo : (a: number) => void +>a : number + + if (a === 10) { +>a === 10 : boolean +>a : number +>10 : 10 + + function foo() { } // duplicate +>foo : { (): void; (): void; } + + foo(); +>foo() : void +>foo : { (): void; (): void; } + + foo(10); // not ok +>foo(10) : any +>foo : { (): void; (): void; } +>10 : 10 + } + else { + function foo() { } // duplicate +>foo : { (): void; (): void; } + + foo(); +>foo() : void +>foo : { (): void; (): void; } + + foo(10);// not ok +>foo(10) : any +>foo : { (): void; (): void; } +>10 : 10 + } + foo(10); // not ok +>foo(10) : any +>foo : { (): void; (): void; } +>10 : 10 + + foo(); +>foo() : void +>foo : { (): void; (): void; } +} +foo(10); +>foo(10) : void +>foo : (a: number) => void +>10 : 10 + +foo(); // not ok - needs number +>foo() : void +>foo : (a: number) => void + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.symbols b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.symbols new file mode 100644 index 00000000000..b7603713a41 --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.symbols @@ -0,0 +1,40 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationStrictES5.ts === +"use strict"; +function foo(a: number) { +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 0, 13)) +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 1, 13)) + + if (a === 1) { +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 1, 13)) + + function foo() { } // Error to declare function in block scope +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 2, 18)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 2, 18)) + + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 2, 18)) + } + else { + function foo() { } // Error to declare function in block scope +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 7, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 7, 10)) + + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 7, 10)) + } + foo(10); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 0, 13)) + + foo(); // not ok - needs number +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 0, 13)) +} +foo(10); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 0, 13)) + +foo(); // not ok - needs number +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES5.ts, 0, 13)) + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.types b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.types new file mode 100644 index 00000000000..d3f4ff88f6e --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES5.types @@ -0,0 +1,56 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationStrictES5.ts === +"use strict"; +>"use strict" : "use strict" + +function foo(a: number) { +>foo : (a: number) => void +>a : number + + if (a === 1) { +>a === 1 : boolean +>a : number +>1 : 1 + + function foo() { } // Error to declare function in block scope +>foo : () => void + + foo(); +>foo() : void +>foo : () => void + + foo(10); // not ok +>foo(10) : void +>foo : () => void +>10 : 10 + } + else { + function foo() { } // Error to declare function in block scope +>foo : () => void + + foo(); +>foo() : void +>foo : () => void + + foo(10); // not ok +>foo(10) : void +>foo : () => void +>10 : 10 + } + foo(10); +>foo(10) : void +>foo : (a: number) => void +>10 : 10 + + foo(); // not ok - needs number +>foo() : void +>foo : (a: number) => void +} +foo(10); +>foo(10) : void +>foo : (a: number) => void +>10 : 10 + +foo(); // not ok - needs number +>foo() : void +>foo : (a: number) => void + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.symbols b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.symbols new file mode 100644 index 00000000000..65adc9fcb1f --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.symbols @@ -0,0 +1,40 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationStrictES6.ts === +"use strict"; +function foo(a: number) { +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 0, 13)) +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 1, 13)) + + if (a === 10) { +>a : Symbol(a, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 1, 13)) + + function foo() { } +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 2, 19)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 2, 19)) + + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 2, 19)) + } + else { + function foo() { } +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 7, 10)) + + foo(); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 7, 10)) + + foo(10); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 7, 10)) + } + foo(10); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 0, 13)) + + foo(); // not ok +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 0, 13)) +} +foo(10); +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 0, 13)) + +foo(); // not ok - needs number +>foo : Symbol(foo, Decl(blockScopedSameNameFunctionDeclarationStrictES6.ts, 0, 13)) + diff --git a/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.types b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.types new file mode 100644 index 00000000000..c80d4d1372a --- /dev/null +++ b/tests/baselines/reference/blockScopedSameNameFunctionDeclarationStrictES6.types @@ -0,0 +1,56 @@ +=== tests/cases/compiler/blockScopedSameNameFunctionDeclarationStrictES6.ts === +"use strict"; +>"use strict" : "use strict" + +function foo(a: number) { +>foo : (a: number) => void +>a : number + + if (a === 10) { +>a === 10 : boolean +>a : number +>10 : 10 + + function foo() { } +>foo : () => void + + foo(); +>foo() : void +>foo : () => void + + foo(10); // not ok +>foo(10) : void +>foo : () => void +>10 : 10 + } + else { + function foo() { } +>foo : () => void + + foo(); +>foo() : void +>foo : () => void + + foo(10); // not ok +>foo(10) : void +>foo : () => void +>10 : 10 + } + foo(10); +>foo(10) : void +>foo : (a: number) => void +>10 : 10 + + foo(); // not ok +>foo() : void +>foo : (a: number) => void +} +foo(10); +>foo(10) : void +>foo : (a: number) => void +>10 : 10 + +foo(); // not ok - needs number +>foo() : void +>foo : (a: number) => void + diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols new file mode 100644 index 00000000000..9dcb26712fb --- /dev/null +++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols @@ -0,0 +1,214 @@ +=== tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts === +function foo0() { +>foo0 : Symbol(foo0, Decl(blockScopedVariablesUseBeforeDef.ts, 0, 0)) + + let a = x; +>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 1, 7)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 2, 7)) + + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 2, 7)) +} + +function foo1() { +>foo1 : Symbol(foo1, Decl(blockScopedVariablesUseBeforeDef.ts, 3, 1)) + + let a = () => x; +>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 6, 7)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 7, 7)) + + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 7, 7)) +} + +function foo2() { +>foo2 : Symbol(foo2, Decl(blockScopedVariablesUseBeforeDef.ts, 8, 1)) + + let a = function () { return x; } +>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 11, 7)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 12, 7)) + + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 12, 7)) +} + +function foo3() { +>foo3 : Symbol(foo3, Decl(blockScopedVariablesUseBeforeDef.ts, 13, 1)) + + class X { +>X : Symbol(X, Decl(blockScopedVariablesUseBeforeDef.ts, 15, 17)) + + m() { return x;} +>m : Symbol(X.m, Decl(blockScopedVariablesUseBeforeDef.ts, 16, 13)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 19, 7)) + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 19, 7)) +} + +function foo4() { +>foo4 : Symbol(foo4, Decl(blockScopedVariablesUseBeforeDef.ts, 20, 1)) + + let y = class { +>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 7)) + + m() { return x; } +>m : Symbol(y.m, Decl(blockScopedVariablesUseBeforeDef.ts, 23, 19)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 26, 7)) + + }; + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 26, 7)) +} + +function foo5() { +>foo5 : Symbol(foo5, Decl(blockScopedVariablesUseBeforeDef.ts, 27, 1)) + + let x = () => y; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 30, 7)) +>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 31, 7)) + + let y = () => x; +>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 31, 7)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 30, 7)) +} + +function foo6() { +>foo6 : Symbol(foo6, Decl(blockScopedVariablesUseBeforeDef.ts, 32, 1)) + + function f() { +>f : Symbol(f, Decl(blockScopedVariablesUseBeforeDef.ts, 34, 17)) + + return x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 38, 7)) + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 38, 7)) +} + +function foo7() { +>foo7 : Symbol(foo7, Decl(blockScopedVariablesUseBeforeDef.ts, 39, 1)) + + class A { +>A : Symbol(A, Decl(blockScopedVariablesUseBeforeDef.ts, 41, 17)) + + a = x; +>a : Symbol(A.a, Decl(blockScopedVariablesUseBeforeDef.ts, 42, 13)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 45, 7)) + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 45, 7)) +} + +function foo8() { +>foo8 : Symbol(foo8, Decl(blockScopedVariablesUseBeforeDef.ts, 46, 1)) + + let y = class { +>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 7)) + + a = x; +>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 49, 19)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 52, 7)) + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 52, 7)) +} + +function foo9() { +>foo9 : Symbol(foo9, Decl(blockScopedVariablesUseBeforeDef.ts, 53, 1)) + + let y = class { +>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 7)) + + static a = x; +>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 56, 19)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 59, 7)) + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 59, 7)) +} + +function foo10() { +>foo10 : Symbol(foo10, Decl(blockScopedVariablesUseBeforeDef.ts, 60, 1)) + + class A { +>A : Symbol(A, Decl(blockScopedVariablesUseBeforeDef.ts, 62, 18)) + + static a = x; +>a : Symbol(A.a, Decl(blockScopedVariablesUseBeforeDef.ts, 63, 13)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 66, 7)) + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 66, 7)) +} + +function foo11() { +>foo11 : Symbol(foo11, Decl(blockScopedVariablesUseBeforeDef.ts, 67, 1)) + + function f () { +>f : Symbol(f, Decl(blockScopedVariablesUseBeforeDef.ts, 69, 18)) + + let y = class { +>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 11)) + + static a = x; +>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 71, 23)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 75, 7)) + } + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 75, 7)) +} + +function foo12() { +>foo12 : Symbol(foo12, Decl(blockScopedVariablesUseBeforeDef.ts, 76, 1)) + + function f () { +>f : Symbol(f, Decl(blockScopedVariablesUseBeforeDef.ts, 78, 18)) + + let y = class { +>y : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 11)) + + a; +>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 23)) + + constructor() { + this.a = x; +>this.a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 23)) +>this : Symbol(y, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 15)) +>a : Symbol(y.a, Decl(blockScopedVariablesUseBeforeDef.ts, 80, 23)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 87, 7)) + } + } + } + let x; +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 87, 7)) +} + +function foo13() { +>foo13 : Symbol(foo13, Decl(blockScopedVariablesUseBeforeDef.ts, 88, 1)) + + let a = { +>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 91, 7)) + + get a() { return x } +>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 91, 13)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 94, 7)) + } + let x +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 94, 7)) +} + +function foo14() { +>foo14 : Symbol(foo14, Decl(blockScopedVariablesUseBeforeDef.ts, 95, 1)) + + let a = { +>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 98, 7)) + + a: x +>a : Symbol(a, Decl(blockScopedVariablesUseBeforeDef.ts, 98, 13)) +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 101, 7)) + } + let x +>x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 101, 7)) +} diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types new file mode 100644 index 00000000000..771518e5901 --- /dev/null +++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types @@ -0,0 +1,226 @@ +=== tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts === +function foo0() { +>foo0 : () => void + + let a = x; +>a : any +>x : any + + let x; +>x : any +} + +function foo1() { +>foo1 : () => void + + let a = () => x; +>a : () => any +>() => x : () => any +>x : any + + let x; +>x : any +} + +function foo2() { +>foo2 : () => void + + let a = function () { return x; } +>a : () => any +>function () { return x; } : () => any +>x : any + + let x; +>x : any +} + +function foo3() { +>foo3 : () => void + + class X { +>X : X + + m() { return x;} +>m : () => any +>x : any + } + let x; +>x : any +} + +function foo4() { +>foo4 : () => void + + let y = class { +>y : typeof y +>class { m() { return x; } } : typeof y + + m() { return x; } +>m : () => any +>x : any + + }; + let x; +>x : any +} + +function foo5() { +>foo5 : () => void + + let x = () => y; +>x : () => () => any +>() => y : () => () => any +>y : () => () => any + + let y = () => x; +>y : () => () => any +>() => x : () => () => any +>x : () => () => any +} + +function foo6() { +>foo6 : () => void + + function f() { +>f : () => any + + return x; +>x : any + } + let x; +>x : any +} + +function foo7() { +>foo7 : () => void + + class A { +>A : A + + a = x; +>a : any +>x : any + } + let x; +>x : any +} + +function foo8() { +>foo8 : () => void + + let y = class { +>y : typeof y +>class { a = x; } : typeof y + + a = x; +>a : any +>x : any + } + let x; +>x : any +} + +function foo9() { +>foo9 : () => void + + let y = class { +>y : typeof y +>class { static a = x; } : typeof y + + static a = x; +>a : any +>x : any + } + let x; +>x : any +} + +function foo10() { +>foo10 : () => void + + class A { +>A : A + + static a = x; +>a : any +>x : any + } + let x; +>x : any +} + +function foo11() { +>foo11 : () => void + + function f () { +>f : () => void + + let y = class { +>y : typeof y +>class { static a = x; } : typeof y + + static a = x; +>a : any +>x : any + } + } + let x; +>x : any +} + +function foo12() { +>foo12 : () => void + + function f () { +>f : () => void + + let y = class { +>y : typeof y +>class { a; constructor() { this.a = x; } } : typeof y + + a; +>a : any + + constructor() { + this.a = x; +>this.a = x : any +>this.a : any +>this : this +>a : any +>x : any + } + } + } + let x; +>x : any +} + +function foo13() { +>foo13 : () => void + + let a = { +>a : { readonly a: any; } +>{ get a() { return x } } : { readonly a: any; } + + get a() { return x } +>a : any +>x : any + } + let x +>x : any +} + +function foo14() { +>foo14 : () => void + + let a = { +>a : { a: any; } +>{ a: x } : { a: any; } + + a: x +>a : any +>x : any + } + let x +>x : any +} diff --git a/tests/baselines/reference/bluebirdStaticThis.symbols b/tests/baselines/reference/bluebirdStaticThis.symbols new file mode 100644 index 00000000000..0fc0cb41bb9 --- /dev/null +++ b/tests/baselines/reference/bluebirdStaticThis.symbols @@ -0,0 +1,1170 @@ +=== tests/cases/compiler/bluebirdStaticThis.ts === +// This version is reduced from the full d.ts by removing almost all the tests +// and all the comments. +// Then it adds explicit `this` arguments to the static members. +// Tests by: Bart van der Schoor +export declare class Promise implements Promise.Thenable { +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 4, 29)) +>Promise.Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 4, 29)) + + constructor(callback: (resolve: (thenableOrResult: R | Promise.Thenable) => void, reject: (error: any) => void) => void); +>callback : Symbol(callback, Decl(bluebirdStaticThis.ts, 5, 13)) +>resolve : Symbol(resolve, Decl(bluebirdStaticThis.ts, 5, 24)) +>thenableOrResult : Symbol(thenableOrResult, Decl(bluebirdStaticThis.ts, 5, 34)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 4, 29)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 4, 29)) +>reject : Symbol(reject, Decl(bluebirdStaticThis.ts, 5, 85)) +>error : Symbol(error, Decl(bluebirdStaticThis.ts, 5, 95)) + + static try(dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; +>try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 6, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 6, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>fn : Symbol(fn, Decl(bluebirdStaticThis.ts, 6, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 6, 15)) +>args : Symbol(args, Decl(bluebirdStaticThis.ts, 6, 69)) +>ctx : Symbol(ctx, Decl(bluebirdStaticThis.ts, 6, 83)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 6, 15)) + + static try(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; +>try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 7, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 7, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>fn : Symbol(fn, Decl(bluebirdStaticThis.ts, 7, 38)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 7, 15)) +>args : Symbol(args, Decl(bluebirdStaticThis.ts, 7, 51)) +>ctx : Symbol(ctx, Decl(bluebirdStaticThis.ts, 7, 65)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 7, 15)) + + static attempt(dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; +>attempt : Symbol(Promise.attempt, Decl(bluebirdStaticThis.ts, 7, 89), Decl(bluebirdStaticThis.ts, 9, 111)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 9, 19)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 9, 22)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>fn : Symbol(fn, Decl(bluebirdStaticThis.ts, 9, 42)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 9, 19)) +>args : Symbol(args, Decl(bluebirdStaticThis.ts, 9, 73)) +>ctx : Symbol(ctx, Decl(bluebirdStaticThis.ts, 9, 87)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 9, 19)) + + static attempt(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; +>attempt : Symbol(Promise.attempt, Decl(bluebirdStaticThis.ts, 7, 89), Decl(bluebirdStaticThis.ts, 9, 111)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 10, 19)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 10, 22)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>fn : Symbol(fn, Decl(bluebirdStaticThis.ts, 10, 42)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 10, 19)) +>args : Symbol(args, Decl(bluebirdStaticThis.ts, 10, 55)) +>ctx : Symbol(ctx, Decl(bluebirdStaticThis.ts, 10, 69)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 10, 19)) + + static method(dit: typeof Promise, fn: Function): Function; +>method : Symbol(Promise.method, Decl(bluebirdStaticThis.ts, 10, 93)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 12, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>fn : Symbol(fn, Decl(bluebirdStaticThis.ts, 12, 38)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + static resolve(dit: typeof Promise): Promise; +>resolve : Symbol(Promise.resolve, Decl(bluebirdStaticThis.ts, 12, 63), Decl(bluebirdStaticThis.ts, 14, 55), Decl(bluebirdStaticThis.ts, 15, 83)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 14, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + static resolve(dit: typeof Promise, value: Promise.Thenable): Promise; +>resolve : Symbol(Promise.resolve, Decl(bluebirdStaticThis.ts, 12, 63), Decl(bluebirdStaticThis.ts, 14, 55), Decl(bluebirdStaticThis.ts, 15, 83)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 15, 19)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 15, 22)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 15, 42)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 15, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 15, 19)) + + static resolve(dit: typeof Promise, value: R): Promise; +>resolve : Symbol(Promise.resolve, Decl(bluebirdStaticThis.ts, 12, 63), Decl(bluebirdStaticThis.ts, 14, 55), Decl(bluebirdStaticThis.ts, 15, 83)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 16, 19)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 16, 22)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 16, 42)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 16, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 16, 19)) + + static reject(dit: typeof Promise, reason: any): Promise; +>reject : Symbol(Promise.reject, Decl(bluebirdStaticThis.ts, 16, 65), Decl(bluebirdStaticThis.ts, 18, 66)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 18, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>reason : Symbol(reason, Decl(bluebirdStaticThis.ts, 18, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + static reject(dit: typeof Promise, reason: any): Promise; +>reject : Symbol(Promise.reject, Decl(bluebirdStaticThis.ts, 16, 65), Decl(bluebirdStaticThis.ts, 18, 66)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 19, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 19, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>reason : Symbol(reason, Decl(bluebirdStaticThis.ts, 19, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 19, 18)) + + static defer(dit: typeof Promise): Promise.Resolver; +>defer : Symbol(Promise.defer, Decl(bluebirdStaticThis.ts, 19, 67)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 21, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 21, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 21, 17)) + + static cast(dit: typeof Promise, value: Promise.Thenable): Promise; +>cast : Symbol(Promise.cast, Decl(bluebirdStaticThis.ts, 21, 62), Decl(bluebirdStaticThis.ts, 23, 80)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 23, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 23, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 23, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 23, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 23, 16)) + + static cast(dit: typeof Promise, value: R): Promise; +>cast : Symbol(Promise.cast, Decl(bluebirdStaticThis.ts, 21, 62), Decl(bluebirdStaticThis.ts, 23, 80)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 24, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 24, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 24, 39)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 24, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 24, 16)) + + static bind(dit: typeof Promise, thisArg: any): Promise; +>bind : Symbol(Promise.bind, Decl(bluebirdStaticThis.ts, 24, 62)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 26, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>thisArg : Symbol(thisArg, Decl(bluebirdStaticThis.ts, 26, 36)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + static is(dit: typeof Promise, value: any): boolean; +>is : Symbol(Promise.is, Decl(bluebirdStaticThis.ts, 26, 66)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 28, 14)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 28, 34)) + + static longStackTraces(dit: typeof Promise): void; +>longStackTraces : Symbol(Promise.longStackTraces, Decl(bluebirdStaticThis.ts, 28, 56)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 30, 27)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + static delay(dit: typeof Promise, value: Promise.Thenable, ms: number): Promise; +>delay : Symbol(Promise.delay, Decl(bluebirdStaticThis.ts, 30, 54), Decl(bluebirdStaticThis.ts, 32, 93), Decl(bluebirdStaticThis.ts, 33, 75)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 32, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 32, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 32, 40)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 32, 17)) +>ms : Symbol(ms, Decl(bluebirdStaticThis.ts, 32, 68)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 32, 17)) + + static delay(dit: typeof Promise, value: R, ms: number): Promise; +>delay : Symbol(Promise.delay, Decl(bluebirdStaticThis.ts, 30, 54), Decl(bluebirdStaticThis.ts, 32, 93), Decl(bluebirdStaticThis.ts, 33, 75)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 33, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 33, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 33, 40)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 33, 17)) +>ms : Symbol(ms, Decl(bluebirdStaticThis.ts, 33, 50)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 33, 17)) + + static delay(dit: typeof Promise, ms: number): Promise; +>delay : Symbol(Promise.delay, Decl(bluebirdStaticThis.ts, 30, 54), Decl(bluebirdStaticThis.ts, 32, 93), Decl(bluebirdStaticThis.ts, 33, 75)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 34, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>ms : Symbol(ms, Decl(bluebirdStaticThis.ts, 34, 37)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + static promisify(dit: typeof Promise, nodeFunction: Function, receiver?: any): Function; +>promisify : Symbol(Promise.promisify, Decl(bluebirdStaticThis.ts, 34, 65)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 36, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>nodeFunction : Symbol(nodeFunction, Decl(bluebirdStaticThis.ts, 36, 41)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>receiver : Symbol(receiver, Decl(bluebirdStaticThis.ts, 36, 65)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + static promisifyAll(dit: typeof Promise, target: Object): Object; +>promisifyAll : Symbol(Promise.promisifyAll, Decl(bluebirdStaticThis.ts, 36, 92)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 38, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>target : Symbol(target, Decl(bluebirdStaticThis.ts, 38, 44)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + static coroutine(dit: typeof Promise, generatorFunction: Function): Function; +>coroutine : Symbol(Promise.coroutine, Decl(bluebirdStaticThis.ts, 38, 69)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 40, 21)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 40, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>generatorFunction : Symbol(generatorFunction, Decl(bluebirdStaticThis.ts, 40, 44)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + static spawn(dit: typeof Promise, generatorFunction: Function): Promise; +>spawn : Symbol(Promise.spawn, Decl(bluebirdStaticThis.ts, 40, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 42, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 42, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>generatorFunction : Symbol(generatorFunction, Decl(bluebirdStaticThis.ts, 42, 40)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 42, 17)) + + static noConflict(dit: typeof Promise): typeof Promise; +>noConflict : Symbol(Promise.noConflict, Decl(bluebirdStaticThis.ts, 42, 82)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 44, 22)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + static onPossiblyUnhandledRejection(dit: typeof Promise, handler: (reason: any) => any): void; +>onPossiblyUnhandledRejection : Symbol(Promise.onPossiblyUnhandledRejection, Decl(bluebirdStaticThis.ts, 44, 59)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 46, 40)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>handler : Symbol(handler, Decl(bluebirdStaticThis.ts, 46, 60)) +>reason : Symbol(reason, Decl(bluebirdStaticThis.ts, 46, 71)) + + static all(dit: typeof Promise, values: Promise.Thenable[]>): Promise; +>all : Symbol(Promise.all, Decl(bluebirdStaticThis.ts, 46, 98), Decl(bluebirdStaticThis.ts, 48, 102), Decl(bluebirdStaticThis.ts, 49, 84), Decl(bluebirdStaticThis.ts, 50, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 48, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 48, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 48, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 48, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 48, 15)) + + static all(dit: typeof Promise, values: Promise.Thenable): Promise; +>all : Symbol(Promise.all, Decl(bluebirdStaticThis.ts, 46, 98), Decl(bluebirdStaticThis.ts, 48, 102), Decl(bluebirdStaticThis.ts, 49, 84), Decl(bluebirdStaticThis.ts, 50, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 49, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 49, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 49, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 49, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 49, 15)) + + static all(dit: typeof Promise, values: Promise.Thenable[]): Promise; +>all : Symbol(Promise.all, Decl(bluebirdStaticThis.ts, 46, 98), Decl(bluebirdStaticThis.ts, 48, 102), Decl(bluebirdStaticThis.ts, 49, 84), Decl(bluebirdStaticThis.ts, 50, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 50, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 50, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 50, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 50, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 50, 15)) + + static all(dit: typeof Promise, values: R[]): Promise; +>all : Symbol(Promise.all, Decl(bluebirdStaticThis.ts, 46, 98), Decl(bluebirdStaticThis.ts, 48, 102), Decl(bluebirdStaticThis.ts, 49, 84), Decl(bluebirdStaticThis.ts, 50, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 51, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 51, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 51, 38)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 51, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 51, 15)) + + static props(dit: typeof Promise, object: Promise): Promise; +>props : Symbol(Promise.props, Decl(bluebirdStaticThis.ts, 51, 66), Decl(bluebirdStaticThis.ts, 53, 80)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 53, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>object : Symbol(object, Decl(bluebirdStaticThis.ts, 53, 37)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + static props(dit: typeof Promise, object: Object): Promise; +>props : Symbol(Promise.props, Decl(bluebirdStaticThis.ts, 51, 66), Decl(bluebirdStaticThis.ts, 53, 80)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 54, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>object : Symbol(object, Decl(bluebirdStaticThis.ts, 54, 37)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + static settle(dit: typeof Promise, values: Promise.Thenable[]>): Promise[]>; +>settle : Symbol(Promise.settle, Decl(bluebirdStaticThis.ts, 54, 71), Decl(bluebirdStaticThis.ts, 56, 125), Decl(bluebirdStaticThis.ts, 57, 107), Decl(bluebirdStaticThis.ts, 58, 107)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 56, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 56, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 56, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 56, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 56, 18)) + + static settle(dit: typeof Promise, values: Promise.Thenable): Promise[]>; +>settle : Symbol(Promise.settle, Decl(bluebirdStaticThis.ts, 54, 71), Decl(bluebirdStaticThis.ts, 56, 125), Decl(bluebirdStaticThis.ts, 57, 107), Decl(bluebirdStaticThis.ts, 58, 107)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 57, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 57, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 57, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 57, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 57, 18)) + + static settle(dit: typeof Promise, values: Promise.Thenable[]): Promise[]>; +>settle : Symbol(Promise.settle, Decl(bluebirdStaticThis.ts, 54, 71), Decl(bluebirdStaticThis.ts, 56, 125), Decl(bluebirdStaticThis.ts, 57, 107), Decl(bluebirdStaticThis.ts, 58, 107)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 58, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 58, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 58, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 58, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 58, 18)) + + static settle(dit: typeof Promise, values: R[]): Promise[]>; +>settle : Symbol(Promise.settle, Decl(bluebirdStaticThis.ts, 54, 71), Decl(bluebirdStaticThis.ts, 56, 125), Decl(bluebirdStaticThis.ts, 57, 107), Decl(bluebirdStaticThis.ts, 58, 107)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 59, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 59, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 59, 41)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 59, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 59, 18)) + + static any(dit: typeof Promise, values: Promise.Thenable[]>): Promise; +>any : Symbol(Promise.any, Decl(bluebirdStaticThis.ts, 59, 89), Decl(bluebirdStaticThis.ts, 61, 100), Decl(bluebirdStaticThis.ts, 62, 82), Decl(bluebirdStaticThis.ts, 63, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 61, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 61, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 61, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 61, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 61, 15)) + + static any(dit: typeof Promise, values: Promise.Thenable): Promise; +>any : Symbol(Promise.any, Decl(bluebirdStaticThis.ts, 59, 89), Decl(bluebirdStaticThis.ts, 61, 100), Decl(bluebirdStaticThis.ts, 62, 82), Decl(bluebirdStaticThis.ts, 63, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 62, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 62, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 62, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 62, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 62, 15)) + + static any(dit: typeof Promise, values: Promise.Thenable[]): Promise; +>any : Symbol(Promise.any, Decl(bluebirdStaticThis.ts, 59, 89), Decl(bluebirdStaticThis.ts, 61, 100), Decl(bluebirdStaticThis.ts, 62, 82), Decl(bluebirdStaticThis.ts, 63, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 63, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 63, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 63, 38)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 63, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 63, 15)) + + static any(dit: typeof Promise, values: R[]): Promise; +>any : Symbol(Promise.any, Decl(bluebirdStaticThis.ts, 59, 89), Decl(bluebirdStaticThis.ts, 61, 100), Decl(bluebirdStaticThis.ts, 62, 82), Decl(bluebirdStaticThis.ts, 63, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 64, 15)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 64, 18)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 64, 38)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 64, 15)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 64, 15)) + + static race(dit: typeof Promise, values: Promise.Thenable[]>): Promise; +>race : Symbol(Promise.race, Decl(bluebirdStaticThis.ts, 64, 64), Decl(bluebirdStaticThis.ts, 66, 101), Decl(bluebirdStaticThis.ts, 67, 83), Decl(bluebirdStaticThis.ts, 68, 83)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 66, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 66, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 66, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 66, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 66, 16)) + + static race(dit: typeof Promise, values: Promise.Thenable): Promise; +>race : Symbol(Promise.race, Decl(bluebirdStaticThis.ts, 64, 64), Decl(bluebirdStaticThis.ts, 66, 101), Decl(bluebirdStaticThis.ts, 67, 83), Decl(bluebirdStaticThis.ts, 68, 83)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 67, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 67, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 67, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 67, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 67, 16)) + + static race(dit: typeof Promise, values: Promise.Thenable[]): Promise; +>race : Symbol(Promise.race, Decl(bluebirdStaticThis.ts, 64, 64), Decl(bluebirdStaticThis.ts, 66, 101), Decl(bluebirdStaticThis.ts, 67, 83), Decl(bluebirdStaticThis.ts, 68, 83)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 68, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 68, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 68, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 68, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 68, 16)) + + static race(dit: typeof Promise, values: R[]): Promise; +>race : Symbol(Promise.race, Decl(bluebirdStaticThis.ts, 64, 64), Decl(bluebirdStaticThis.ts, 66, 101), Decl(bluebirdStaticThis.ts, 67, 83), Decl(bluebirdStaticThis.ts, 68, 83)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 69, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 69, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 69, 39)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 69, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 69, 16)) + + static some(dit: typeof Promise, values: Promise.Thenable[]>, count: number): Promise; +>some : Symbol(Promise.some, Decl(bluebirdStaticThis.ts, 69, 65), Decl(bluebirdStaticThis.ts, 71, 118), Decl(bluebirdStaticThis.ts, 72, 100), Decl(bluebirdStaticThis.ts, 73, 100)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 71, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 71, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 71, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 71, 16)) +>count : Symbol(count, Decl(bluebirdStaticThis.ts, 71, 88)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 71, 16)) + + static some(dit: typeof Promise, values: Promise.Thenable, count: number): Promise; +>some : Symbol(Promise.some, Decl(bluebirdStaticThis.ts, 69, 65), Decl(bluebirdStaticThis.ts, 71, 118), Decl(bluebirdStaticThis.ts, 72, 100), Decl(bluebirdStaticThis.ts, 73, 100)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 72, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 72, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 72, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 72, 16)) +>count : Symbol(count, Decl(bluebirdStaticThis.ts, 72, 70)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 72, 16)) + + static some(dit: typeof Promise, values: Promise.Thenable[], count: number): Promise; +>some : Symbol(Promise.some, Decl(bluebirdStaticThis.ts, 69, 65), Decl(bluebirdStaticThis.ts, 71, 118), Decl(bluebirdStaticThis.ts, 72, 100), Decl(bluebirdStaticThis.ts, 73, 100)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 73, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 73, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 73, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 73, 16)) +>count : Symbol(count, Decl(bluebirdStaticThis.ts, 73, 70)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 73, 16)) + + static some(dit: typeof Promise, values: R[], count: number): Promise; +>some : Symbol(Promise.some, Decl(bluebirdStaticThis.ts, 69, 65), Decl(bluebirdStaticThis.ts, 71, 118), Decl(bluebirdStaticThis.ts, 72, 100), Decl(bluebirdStaticThis.ts, 73, 100)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 74, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 74, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 74, 39)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 74, 16)) +>count : Symbol(count, Decl(bluebirdStaticThis.ts, 74, 52)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 74, 16)) + + static join(dit: typeof Promise, ...values: Promise.Thenable[]): Promise; +>join : Symbol(Promise.join, Decl(bluebirdStaticThis.ts, 74, 82), Decl(bluebirdStaticThis.ts, 76, 88)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 76, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 76, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 76, 39)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 76, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 76, 16)) + + static join(dit: typeof Promise, ...values: R[]): Promise; +>join : Symbol(Promise.join, Decl(bluebirdStaticThis.ts, 74, 82), Decl(bluebirdStaticThis.ts, 76, 88)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 77, 16)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 77, 19)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 77, 39)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 77, 16)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 77, 16)) + + static map(dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 79, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 79, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 79, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 79, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 79, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 79, 90)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 79, 100)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 79, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 79, 108)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 79, 123)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 79, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 79, 17)) + + static map(dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 80, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 80, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 80, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 80, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 80, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 80, 90)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 80, 100)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 80, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 80, 108)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 80, 123)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 80, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 80, 17)) + + static map(dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 81, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 81, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 81, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 81, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 81, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 81, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 81, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 81, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 81, 90)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 81, 105)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 81, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 81, 17)) + + static map(dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 82, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 82, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 82, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 82, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 82, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 82, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 82, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 82, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 82, 90)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 82, 105)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 82, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 82, 17)) + + static map(dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 83, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 83, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 83, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 83, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 83, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 83, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 83, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 83, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 83, 90)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 83, 105)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 83, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 83, 17)) + + static map(dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 84, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 84, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 84, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 84, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 84, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 84, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 84, 82)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 84, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 84, 90)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 84, 105)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 84, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 84, 17)) + + static map(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 85, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 85, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 85, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 85, 41)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 85, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 85, 54)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 85, 64)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 85, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 85, 72)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 85, 87)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 85, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 85, 17)) + + static map(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : Symbol(Promise.map, Decl(bluebirdStaticThis.ts, 77, 70), Decl(bluebirdStaticThis.ts, 79, 183), Decl(bluebirdStaticThis.ts, 80, 165), Decl(bluebirdStaticThis.ts, 81, 165), Decl(bluebirdStaticThis.ts, 82, 147) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 86, 15)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 86, 17)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 86, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 86, 41)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 86, 15)) +>mapper : Symbol(mapper, Decl(bluebirdStaticThis.ts, 86, 54)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 86, 64)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 86, 15)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 86, 72)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 86, 87)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 86, 17)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 86, 17)) + + static reduce(dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 88, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 88, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 88, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 88, 44)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 88, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 88, 93)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 88, 104)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 88, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 88, 113)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 88, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 88, 125)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 88, 140)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 88, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 88, 185)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 88, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 88, 20)) + + static reduce(dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 89, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 89, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 89, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 89, 44)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 89, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 89, 93)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 89, 104)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 89, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 89, 113)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 89, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 89, 125)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 89, 140)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 89, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 89, 167)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 89, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 89, 20)) + + static reduce(dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 91, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 91, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 91, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 91, 44)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 91, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 91, 75)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 91, 86)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 91, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 91, 95)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 91, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 91, 107)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 91, 122)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 91, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 91, 167)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 91, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 91, 20)) + + static reduce(dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 92, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 92, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 92, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 92, 44)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 92, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 92, 75)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 92, 86)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 92, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 92, 95)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 92, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 92, 107)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 92, 122)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 92, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 92, 149)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 92, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 92, 20)) + + static reduce(dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 94, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 94, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 94, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 94, 44)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 94, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 94, 75)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 94, 86)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 94, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 94, 95)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 94, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 94, 107)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 94, 122)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 94, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 94, 167)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 94, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 94, 20)) + + static reduce(dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 95, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 95, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 95, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 95, 44)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 95, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 95, 75)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 95, 86)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 95, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 95, 95)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 95, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 95, 107)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 95, 122)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 95, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 95, 149)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 95, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 95, 20)) + + static reduce(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 97, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 97, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 97, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 97, 44)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 97, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 97, 57)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 97, 68)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 97, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 97, 77)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 97, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 97, 89)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 97, 104)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 97, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 97, 149)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 97, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 97, 20)) + + static reduce(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : Symbol(Promise.reduce, Decl(bluebirdStaticThis.ts, 86, 129), Decl(bluebirdStaticThis.ts, 88, 216), Decl(bluebirdStaticThis.ts, 89, 198), Decl(bluebirdStaticThis.ts, 91, 198), Decl(bluebirdStaticThis.ts, 92, 180) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 98, 18)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 98, 20)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 98, 24)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 98, 44)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 98, 18)) +>reducer : Symbol(reducer, Decl(bluebirdStaticThis.ts, 98, 57)) +>total : Symbol(total, Decl(bluebirdStaticThis.ts, 98, 68)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 98, 20)) +>current : Symbol(current, Decl(bluebirdStaticThis.ts, 98, 77)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 98, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 98, 89)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 98, 104)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 98, 20)) +>initialValue : Symbol(initialValue, Decl(bluebirdStaticThis.ts, 98, 131)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 98, 20)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 98, 20)) + + static filter(dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 100, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 100, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 100, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 100, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 100, 90)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 100, 102)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 100, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 100, 110)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 100, 125)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 100, 18)) + + static filter(dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 101, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 101, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 101, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 101, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 101, 90)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 101, 102)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 101, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 101, 110)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 101, 125)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 101, 18)) + + static filter(dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 102, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 102, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 102, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 102, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 102, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 102, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 102, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 102, 92)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 102, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 102, 18)) + + static filter(dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 103, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 103, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 103, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 103, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 103, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 103, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 103, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 103, 92)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 103, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 103, 18)) + + static filter(dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 104, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 104, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 104, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 104, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 104, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 104, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 104, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 104, 92)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 104, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 104, 18)) + + static filter(dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 105, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 105, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 105, 41)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 105, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 105, 72)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 105, 84)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 105, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 105, 92)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 105, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 105, 18)) + + static filter(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 106, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 106, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 106, 41)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 106, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 106, 54)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 106, 66)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 106, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 106, 74)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 106, 89)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Thenable : Symbol(Promise.Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 106, 18)) + + static filter(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : Symbol(Promise.filter, Decl(bluebirdStaticThis.ts, 98, 162), Decl(bluebirdStaticThis.ts, 100, 191), Decl(bluebirdStaticThis.ts, 101, 173), Decl(bluebirdStaticThis.ts, 102, 173), Decl(bluebirdStaticThis.ts, 103, 155) ... and 3 more) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 107, 18)) +>dit : Symbol(dit, Decl(bluebirdStaticThis.ts, 107, 21)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>values : Symbol(values, Decl(bluebirdStaticThis.ts, 107, 41)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 107, 18)) +>filterer : Symbol(filterer, Decl(bluebirdStaticThis.ts, 107, 54)) +>item : Symbol(item, Decl(bluebirdStaticThis.ts, 107, 66)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 107, 18)) +>index : Symbol(index, Decl(bluebirdStaticThis.ts, 107, 74)) +>arrayLength : Symbol(arrayLength, Decl(bluebirdStaticThis.ts, 107, 89)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 107, 18)) +} + +export declare module Promise { +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + export interface Thenable { +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 111, 27)) + + then(onFulfilled: (value: R) => Thenable, onRejected: (error: any) => Thenable): Thenable; +>then : Symbol(Thenable.then, Decl(bluebirdStaticThis.ts, 111, 31), Decl(bluebirdStaticThis.ts, 112, 104), Decl(bluebirdStaticThis.ts, 113, 95), Decl(bluebirdStaticThis.ts, 114, 94)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 112, 7)) +>onFulfilled : Symbol(onFulfilled, Decl(bluebirdStaticThis.ts, 112, 10)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 112, 24)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 111, 27)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 112, 7)) +>onRejected : Symbol(onRejected, Decl(bluebirdStaticThis.ts, 112, 49)) +>error : Symbol(error, Decl(bluebirdStaticThis.ts, 112, 63)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 112, 7)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 112, 7)) + + then(onFulfilled: (value: R) => Thenable, onRejected?: (error: any) => U): Thenable; +>then : Symbol(Thenable.then, Decl(bluebirdStaticThis.ts, 111, 31), Decl(bluebirdStaticThis.ts, 112, 104), Decl(bluebirdStaticThis.ts, 113, 95), Decl(bluebirdStaticThis.ts, 114, 94)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 113, 7)) +>onFulfilled : Symbol(onFulfilled, Decl(bluebirdStaticThis.ts, 113, 10)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 113, 24)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 111, 27)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 113, 7)) +>onRejected : Symbol(onRejected, Decl(bluebirdStaticThis.ts, 113, 49)) +>error : Symbol(error, Decl(bluebirdStaticThis.ts, 113, 64)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 113, 7)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 113, 7)) + + then(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable): Thenable; +>then : Symbol(Thenable.then, Decl(bluebirdStaticThis.ts, 111, 31), Decl(bluebirdStaticThis.ts, 112, 104), Decl(bluebirdStaticThis.ts, 113, 95), Decl(bluebirdStaticThis.ts, 114, 94)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 114, 7)) +>onFulfilled : Symbol(onFulfilled, Decl(bluebirdStaticThis.ts, 114, 10)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 114, 24)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 111, 27)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 114, 7)) +>onRejected : Symbol(onRejected, Decl(bluebirdStaticThis.ts, 114, 39)) +>error : Symbol(error, Decl(bluebirdStaticThis.ts, 114, 53)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 114, 7)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 114, 7)) + + then(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable; +>then : Symbol(Thenable.then, Decl(bluebirdStaticThis.ts, 111, 31), Decl(bluebirdStaticThis.ts, 112, 104), Decl(bluebirdStaticThis.ts, 113, 95), Decl(bluebirdStaticThis.ts, 114, 94)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 115, 7)) +>onFulfilled : Symbol(onFulfilled, Decl(bluebirdStaticThis.ts, 115, 10)) +>value : Symbol(value, Decl(bluebirdStaticThis.ts, 115, 25)) +>R : Symbol(R, Decl(bluebirdStaticThis.ts, 111, 27)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 115, 7)) +>onRejected : Symbol(onRejected, Decl(bluebirdStaticThis.ts, 115, 40)) +>error : Symbol(error, Decl(bluebirdStaticThis.ts, 115, 55)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 115, 7)) +>Thenable : Symbol(Thenable, Decl(bluebirdStaticThis.ts, 110, 31)) +>U : Symbol(U, Decl(bluebirdStaticThis.ts, 115, 7)) + } + +} + +interface Foo { +>Foo : Symbol(Foo, Decl(bluebirdStaticThis.ts, 118, 1)) + + a: number; +>a : Symbol(Foo.a, Decl(bluebirdStaticThis.ts, 120, 15)) + + b: string; +>b : Symbol(Foo.b, Decl(bluebirdStaticThis.ts, 121, 14)) +} +var x: any; +>x : Symbol(x, Decl(bluebirdStaticThis.ts, 124, 3)) + +var arr: any[]; +>arr : Symbol(arr, Decl(bluebirdStaticThis.ts, 125, 3)) + +var foo: Foo; +>foo : Symbol(foo, Decl(bluebirdStaticThis.ts, 126, 3)) +>Foo : Symbol(Foo, Decl(bluebirdStaticThis.ts, 118, 1)) + +var fooProm: Promise; +>fooProm : Symbol(fooProm, Decl(bluebirdStaticThis.ts, 127, 3)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>Foo : Symbol(Foo, Decl(bluebirdStaticThis.ts, 118, 1)) + +fooProm = Promise.try(Promise, () => { +>fooProm : Symbol(fooProm, Decl(bluebirdStaticThis.ts, 127, 3)) +>Promise.try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + return foo; +>foo : Symbol(foo, Decl(bluebirdStaticThis.ts, 126, 3)) + +}); +fooProm = Promise.try(Promise, () => { +>fooProm : Symbol(fooProm, Decl(bluebirdStaticThis.ts, 127, 3)) +>Promise.try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + return foo; +>foo : Symbol(foo, Decl(bluebirdStaticThis.ts, 126, 3)) + +}, arr); +>arr : Symbol(arr, Decl(bluebirdStaticThis.ts, 125, 3)) + +fooProm = Promise.try(Promise, () => { +>fooProm : Symbol(fooProm, Decl(bluebirdStaticThis.ts, 127, 3)) +>Promise.try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) +>try : Symbol(Promise.try, Decl(bluebirdStaticThis.ts, 5, 125), Decl(bluebirdStaticThis.ts, 6, 107)) +>Promise : Symbol(Promise, Decl(bluebirdStaticThis.ts, 0, 0), Decl(bluebirdStaticThis.ts, 108, 1)) + + return foo; +>foo : Symbol(foo, Decl(bluebirdStaticThis.ts, 126, 3)) + +}, arr, x); +>arr : Symbol(arr, Decl(bluebirdStaticThis.ts, 125, 3)) +>x : Symbol(x, Decl(bluebirdStaticThis.ts, 124, 3)) + diff --git a/tests/baselines/reference/bluebirdStaticThis.types b/tests/baselines/reference/bluebirdStaticThis.types new file mode 100644 index 00000000000..a3a968cd828 --- /dev/null +++ b/tests/baselines/reference/bluebirdStaticThis.types @@ -0,0 +1,1184 @@ +=== tests/cases/compiler/bluebirdStaticThis.ts === +// This version is reduced from the full d.ts by removing almost all the tests +// and all the comments. +// Then it adds explicit `this` arguments to the static members. +// Tests by: Bart van der Schoor +export declare class Promise implements Promise.Thenable { +>Promise : Promise +>R : R +>Promise.Thenable : any +>Promise : typeof Promise +>Thenable : Promise.Thenable +>R : R + + constructor(callback: (resolve: (thenableOrResult: R | Promise.Thenable) => void, reject: (error: any) => void) => void); +>callback : (resolve: (thenableOrResult: R | Promise.Thenable) => void, reject: (error: any) => void) => void +>resolve : (thenableOrResult: R | Promise.Thenable) => void +>thenableOrResult : R | Promise.Thenable +>R : R +>Promise : any +>Thenable : Promise.Thenable +>R : R +>reject : (error: any) => void +>error : any + + static try(dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; +>try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>fn : () => Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>args : any[] +>ctx : any +>Promise : Promise +>R : R + + static try(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; +>try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>fn : () => R +>R : R +>args : any[] +>ctx : any +>Promise : Promise +>R : R + + static attempt(dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; +>attempt : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>fn : () => Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>args : any[] +>ctx : any +>Promise : Promise +>R : R + + static attempt(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; +>attempt : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>fn : () => R +>R : R +>args : any[] +>ctx : any +>Promise : Promise +>R : R + + static method(dit: typeof Promise, fn: Function): Function; +>method : (dit: typeof Promise, fn: Function) => Function +>dit : typeof Promise +>Promise : typeof Promise +>fn : Function +>Function : Function +>Function : Function + + static resolve(dit: typeof Promise): Promise; +>resolve : { (dit: typeof Promise): Promise; (dit: typeof Promise, value: Promise.Thenable): Promise; (dit: typeof Promise, value: R): Promise; } +>dit : typeof Promise +>Promise : typeof Promise +>Promise : Promise + + static resolve(dit: typeof Promise, value: Promise.Thenable): Promise; +>resolve : { (dit: typeof Promise): Promise; (dit: typeof Promise, value: Promise.Thenable): Promise; (dit: typeof Promise, value: R): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>value : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static resolve(dit: typeof Promise, value: R): Promise; +>resolve : { (dit: typeof Promise): Promise; (dit: typeof Promise, value: Promise.Thenable): Promise; (dit: typeof Promise, value: R): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>value : R +>R : R +>Promise : Promise +>R : R + + static reject(dit: typeof Promise, reason: any): Promise; +>reject : { (dit: typeof Promise, reason: any): Promise; (dit: typeof Promise, reason: any): Promise; } +>dit : typeof Promise +>Promise : typeof Promise +>reason : any +>Promise : Promise + + static reject(dit: typeof Promise, reason: any): Promise; +>reject : { (dit: typeof Promise, reason: any): Promise; (dit: typeof Promise, reason: any): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>reason : any +>Promise : Promise +>R : R + + static defer(dit: typeof Promise): Promise.Resolver; +>defer : (dit: typeof Promise) => any +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>Promise : any +>Resolver : No type information available! +>R : R + + static cast(dit: typeof Promise, value: Promise.Thenable): Promise; +>cast : { (dit: typeof Promise, value: Promise.Thenable): Promise; (dit: typeof Promise, value: R): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>value : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static cast(dit: typeof Promise, value: R): Promise; +>cast : { (dit: typeof Promise, value: Promise.Thenable): Promise; (dit: typeof Promise, value: R): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>value : R +>R : R +>Promise : Promise +>R : R + + static bind(dit: typeof Promise, thisArg: any): Promise; +>bind : (dit: typeof Promise, thisArg: any) => Promise +>dit : typeof Promise +>Promise : typeof Promise +>thisArg : any +>Promise : Promise + + static is(dit: typeof Promise, value: any): boolean; +>is : (dit: typeof Promise, value: any) => boolean +>dit : typeof Promise +>Promise : typeof Promise +>value : any + + static longStackTraces(dit: typeof Promise): void; +>longStackTraces : (dit: typeof Promise) => void +>dit : typeof Promise +>Promise : typeof Promise + + static delay(dit: typeof Promise, value: Promise.Thenable, ms: number): Promise; +>delay : { (dit: typeof Promise, value: Promise.Thenable, ms: number): Promise; (dit: typeof Promise, value: R, ms: number): Promise; (dit: typeof Promise, ms: number): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>value : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>ms : number +>Promise : Promise +>R : R + + static delay(dit: typeof Promise, value: R, ms: number): Promise; +>delay : { (dit: typeof Promise, value: Promise.Thenable, ms: number): Promise; (dit: typeof Promise, value: R, ms: number): Promise; (dit: typeof Promise, ms: number): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>value : R +>R : R +>ms : number +>Promise : Promise +>R : R + + static delay(dit: typeof Promise, ms: number): Promise; +>delay : { (dit: typeof Promise, value: Promise.Thenable, ms: number): Promise; (dit: typeof Promise, value: R, ms: number): Promise; (dit: typeof Promise, ms: number): Promise; } +>dit : typeof Promise +>Promise : typeof Promise +>ms : number +>Promise : Promise + + static promisify(dit: typeof Promise, nodeFunction: Function, receiver?: any): Function; +>promisify : (dit: typeof Promise, nodeFunction: Function, receiver?: any) => Function +>dit : typeof Promise +>Promise : typeof Promise +>nodeFunction : Function +>Function : Function +>receiver : any +>Function : Function + + static promisifyAll(dit: typeof Promise, target: Object): Object; +>promisifyAll : (dit: typeof Promise, target: Object) => Object +>dit : typeof Promise +>Promise : typeof Promise +>target : Object +>Object : Object +>Object : Object + + static coroutine(dit: typeof Promise, generatorFunction: Function): Function; +>coroutine : (dit: typeof Promise, generatorFunction: Function) => Function +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>generatorFunction : Function +>Function : Function +>Function : Function + + static spawn(dit: typeof Promise, generatorFunction: Function): Promise; +>spawn : (dit: typeof Promise, generatorFunction: Function) => Promise +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>generatorFunction : Function +>Function : Function +>Promise : Promise +>R : R + + static noConflict(dit: typeof Promise): typeof Promise; +>noConflict : (dit: typeof Promise) => typeof Promise +>dit : typeof Promise +>Promise : typeof Promise +>Promise : typeof Promise + + static onPossiblyUnhandledRejection(dit: typeof Promise, handler: (reason: any) => any): void; +>onPossiblyUnhandledRejection : (dit: typeof Promise, handler: (reason: any) => any) => void +>dit : typeof Promise +>Promise : typeof Promise +>handler : (reason: any) => any +>reason : any + + static all(dit: typeof Promise, values: Promise.Thenable[]>): Promise; +>all : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static all(dit: typeof Promise, values: Promise.Thenable): Promise; +>all : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static all(dit: typeof Promise, values: Promise.Thenable[]): Promise; +>all : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static all(dit: typeof Promise, values: R[]): Promise; +>all : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>Promise : Promise +>R : R + + static props(dit: typeof Promise, object: Promise): Promise; +>props : { (dit: typeof Promise, object: Promise): Promise; (dit: typeof Promise, object: Object): Promise; } +>dit : typeof Promise +>Promise : typeof Promise +>object : Promise +>Promise : Promise +>Object : Object +>Promise : Promise +>Object : Object + + static props(dit: typeof Promise, object: Object): Promise; +>props : { (dit: typeof Promise, object: Promise): Promise; (dit: typeof Promise, object: Object): Promise; } +>dit : typeof Promise +>Promise : typeof Promise +>object : Object +>Object : Object +>Promise : Promise +>Object : Object + + static settle(dit: typeof Promise, values: Promise.Thenable[]>): Promise[]>; +>settle : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>Promise : any +>Inspection : No type information available! +>R : R + + static settle(dit: typeof Promise, values: Promise.Thenable): Promise[]>; +>settle : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>Promise : any +>Inspection : No type information available! +>R : R + + static settle(dit: typeof Promise, values: Promise.Thenable[]): Promise[]>; +>settle : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>Promise : any +>Inspection : No type information available! +>R : R + + static settle(dit: typeof Promise, values: R[]): Promise[]>; +>settle : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>Promise : Promise +>Promise : any +>Inspection : No type information available! +>R : R + + static any(dit: typeof Promise, values: Promise.Thenable[]>): Promise; +>any : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static any(dit: typeof Promise, values: Promise.Thenable): Promise; +>any : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static any(dit: typeof Promise, values: Promise.Thenable[]): Promise; +>any : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static any(dit: typeof Promise, values: R[]): Promise; +>any : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>Promise : Promise +>R : R + + static race(dit: typeof Promise, values: Promise.Thenable[]>): Promise; +>race : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static race(dit: typeof Promise, values: Promise.Thenable): Promise; +>race : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static race(dit: typeof Promise, values: Promise.Thenable[]): Promise; +>race : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static race(dit: typeof Promise, values: R[]): Promise; +>race : { (dit: typeof Promise, values: Promise.Thenable[]>): Promise; (dit: typeof Promise, values: Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]): Promise; (dit: typeof Promise, values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>Promise : Promise +>R : R + + static some(dit: typeof Promise, values: Promise.Thenable[]>, count: number): Promise; +>some : { (dit: typeof Promise, values: Promise.Thenable[]>, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable[], count: number): Promise; (dit: typeof Promise, values: R[], count: number): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>count : number +>Promise : Promise +>R : R + + static some(dit: typeof Promise, values: Promise.Thenable, count: number): Promise; +>some : { (dit: typeof Promise, values: Promise.Thenable[]>, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable[], count: number): Promise; (dit: typeof Promise, values: R[], count: number): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>count : number +>Promise : Promise +>R : R + + static some(dit: typeof Promise, values: Promise.Thenable[], count: number): Promise; +>some : { (dit: typeof Promise, values: Promise.Thenable[]>, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable[], count: number): Promise; (dit: typeof Promise, values: R[], count: number): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>count : number +>Promise : Promise +>R : R + + static some(dit: typeof Promise, values: R[], count: number): Promise; +>some : { (dit: typeof Promise, values: Promise.Thenable[]>, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable, count: number): Promise; (dit: typeof Promise, values: Promise.Thenable[], count: number): Promise; (dit: typeof Promise, values: R[], count: number): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>count : number +>Promise : Promise +>R : R + + static join(dit: typeof Promise, ...values: Promise.Thenable[]): Promise; +>join : { (dit: typeof Promise, ...values: Promise.Thenable[]): Promise; (dit: typeof Promise, ...values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>Promise : Promise +>R : R + + static join(dit: typeof Promise, ...values: R[]): Promise; +>join : { (dit: typeof Promise, ...values: Promise.Thenable[]): Promise; (dit: typeof Promise, ...values: R[]): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>Promise : Promise +>R : R + + static map(dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>mapper : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>Promise : Promise +>U : U + + static map(dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>mapper : (item: R, index: number, arrayLength: number) => U +>item : R +>R : R +>index : number +>arrayLength : number +>U : U +>Promise : Promise +>U : U + + static map(dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>mapper : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>Promise : Promise +>U : U + + static map(dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>mapper : (item: R, index: number, arrayLength: number) => U +>item : R +>R : R +>index : number +>arrayLength : number +>U : U +>Promise : Promise +>U : U + + static map(dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>mapper : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>Promise : Promise +>U : U + + static map(dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>mapper : (item: R, index: number, arrayLength: number) => U +>item : R +>R : R +>index : number +>arrayLength : number +>U : U +>Promise : Promise +>U : U + + static map(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>mapper : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>Promise : Promise +>U : U + + static map(dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; +>map : { (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>mapper : (item: R, index: number, arrayLength: number) => U +>item : R +>R : R +>index : number +>arrayLength : number +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => U +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => U +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => U +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static reduce(dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; +>reduce : { (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; (dit: typeof Promise, values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; } +>R : R +>U : U +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>reducer : (total: U, current: R, index: number, arrayLength: number) => U +>total : U +>U : U +>current : R +>R : R +>index : number +>arrayLength : number +>U : U +>initialValue : U +>U : U +>Promise : Promise +>U : U + + static filter(dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>filterer : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>Promise : Promise +>R : R + + static filter(dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[]> +>Promise : any +>Thenable : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>filterer : (item: R, index: number, arrayLength: number) => boolean +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : Promise +>R : R + + static filter(dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>filterer : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>Promise : Promise +>R : R + + static filter(dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable +>Promise : any +>Thenable : Promise.Thenable +>R : R +>filterer : (item: R, index: number, arrayLength: number) => boolean +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : Promise +>R : R + + static filter(dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>filterer : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>Promise : Promise +>R : R + + static filter(dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : Promise.Thenable[] +>Promise : any +>Thenable : Promise.Thenable +>R : R +>filterer : (item: R, index: number, arrayLength: number) => boolean +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : Promise +>R : R + + static filter(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>filterer : (item: R, index: number, arrayLength: number) => Promise.Thenable +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : any +>Thenable : Promise.Thenable +>Promise : Promise +>R : R + + static filter(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +>filter : { (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; (dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; } +>R : R +>dit : typeof Promise +>Promise : typeof Promise +>values : R[] +>R : R +>filterer : (item: R, index: number, arrayLength: number) => boolean +>item : R +>R : R +>index : number +>arrayLength : number +>Promise : Promise +>R : R +} + +export declare module Promise { +>Promise : typeof Promise + + export interface Thenable { +>Thenable : Thenable +>R : R + + then(onFulfilled: (value: R) => Thenable, onRejected: (error: any) => Thenable): Thenable; +>then : { (onFulfilled: (value: R) => Thenable, onRejected: (error: any) => Thenable): Thenable; (onFulfilled: (value: R) => Thenable, onRejected?: (error: any) => U): Thenable; (onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable): Thenable; (onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable; } +>U : U +>onFulfilled : (value: R) => Thenable +>value : R +>R : R +>Thenable : Thenable +>U : U +>onRejected : (error: any) => Thenable +>error : any +>Thenable : Thenable +>U : U +>Thenable : Thenable +>U : U + + then(onFulfilled: (value: R) => Thenable, onRejected?: (error: any) => U): Thenable; +>then : { (onFulfilled: (value: R) => Thenable, onRejected: (error: any) => Thenable): Thenable; (onFulfilled: (value: R) => Thenable, onRejected?: (error: any) => U): Thenable; (onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable): Thenable; (onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable; } +>U : U +>onFulfilled : (value: R) => Thenable +>value : R +>R : R +>Thenable : Thenable +>U : U +>onRejected : (error: any) => U +>error : any +>U : U +>Thenable : Thenable +>U : U + + then(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable): Thenable; +>then : { (onFulfilled: (value: R) => Thenable, onRejected: (error: any) => Thenable): Thenable; (onFulfilled: (value: R) => Thenable, onRejected?: (error: any) => U): Thenable; (onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable): Thenable; (onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable; } +>U : U +>onFulfilled : (value: R) => U +>value : R +>R : R +>U : U +>onRejected : (error: any) => Thenable +>error : any +>Thenable : Thenable +>U : U +>Thenable : Thenable +>U : U + + then(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable; +>then : { (onFulfilled: (value: R) => Thenable, onRejected: (error: any) => Thenable): Thenable; (onFulfilled: (value: R) => Thenable, onRejected?: (error: any) => U): Thenable; (onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable): Thenable; (onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable; } +>U : U +>onFulfilled : (value: R) => U +>value : R +>R : R +>U : U +>onRejected : (error: any) => U +>error : any +>U : U +>Thenable : Thenable +>U : U + } + +} + +interface Foo { +>Foo : Foo + + a: number; +>a : number + + b: string; +>b : string +} +var x: any; +>x : any + +var arr: any[]; +>arr : any[] + +var foo: Foo; +>foo : Foo +>Foo : Foo + +var fooProm: Promise; +>fooProm : Promise +>Promise : Promise +>Foo : Foo + +fooProm = Promise.try(Promise, () => { +>fooProm = Promise.try(Promise, () => { return foo;}) : Promise +>fooProm : Promise +>Promise.try(Promise, () => { return foo;}) : Promise +>Promise.try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>Promise : typeof Promise +>try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>Promise : typeof Promise +>() => { return foo;} : () => Foo + + return foo; +>foo : Foo + +}); +fooProm = Promise.try(Promise, () => { +>fooProm = Promise.try(Promise, () => { return foo;}, arr) : Promise +>fooProm : Promise +>Promise.try(Promise, () => { return foo;}, arr) : Promise +>Promise.try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>Promise : typeof Promise +>try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>Promise : typeof Promise +>() => { return foo;} : () => Foo + + return foo; +>foo : Foo + +}, arr); +>arr : any[] + +fooProm = Promise.try(Promise, () => { +>fooProm = Promise.try(Promise, () => { return foo;}, arr, x) : Promise +>fooProm : Promise +>Promise.try(Promise, () => { return foo;}, arr, x) : Promise +>Promise.try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>Promise : typeof Promise +>try : { (dit: typeof Promise, fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; (dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise; } +>Promise : typeof Promise +>() => { return foo;} : () => Foo + + return foo; +>foo : Foo + +}, arr, x); +>arr : any[] +>x : any + diff --git a/tests/baselines/reference/boolInsteadOfBoolean.symbols b/tests/baselines/reference/boolInsteadOfBoolean.symbols new file mode 100644 index 00000000000..dcfced8fe77 --- /dev/null +++ b/tests/baselines/reference/boolInsteadOfBoolean.symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/types/primitives/boolean/boolInsteadOfBoolean.ts === +var x: bool; +>x : Symbol(x, Decl(boolInsteadOfBoolean.ts, 0, 3)) + +var a: boolean = x; +>a : Symbol(a, Decl(boolInsteadOfBoolean.ts, 1, 3)) +>x : Symbol(x, Decl(boolInsteadOfBoolean.ts, 0, 3)) + +x = a; +>x : Symbol(x, Decl(boolInsteadOfBoolean.ts, 0, 3)) +>a : Symbol(a, Decl(boolInsteadOfBoolean.ts, 1, 3)) + diff --git a/tests/baselines/reference/boolInsteadOfBoolean.types b/tests/baselines/reference/boolInsteadOfBoolean.types new file mode 100644 index 00000000000..b22e09393c0 --- /dev/null +++ b/tests/baselines/reference/boolInsteadOfBoolean.types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/types/primitives/boolean/boolInsteadOfBoolean.ts === +var x: bool; +>x : any +>bool : No type information available! + +var a: boolean = x; +>a : boolean +>x : any + +x = a; +>x = a : boolean +>x : any +>a : boolean + diff --git a/tests/baselines/reference/booleanAssignment.symbols b/tests/baselines/reference/booleanAssignment.symbols new file mode 100644 index 00000000000..bc9da786c8d --- /dev/null +++ b/tests/baselines/reference/booleanAssignment.symbols @@ -0,0 +1,31 @@ +=== tests/cases/compiler/booleanAssignment.ts === +var b = new Boolean(); +>b : Symbol(b, Decl(booleanAssignment.ts, 0, 3)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +b = 1; // Error +>b : Symbol(b, Decl(booleanAssignment.ts, 0, 3)) + +b = "a"; // Error +>b : Symbol(b, Decl(booleanAssignment.ts, 0, 3)) + +b = {}; // Error +>b : Symbol(b, Decl(booleanAssignment.ts, 0, 3)) + +var o = {}; +>o : Symbol(o, Decl(booleanAssignment.ts, 5, 3)) + +o = b; // OK +>o : Symbol(o, Decl(booleanAssignment.ts, 5, 3)) +>b : Symbol(b, Decl(booleanAssignment.ts, 0, 3)) + +b = true; // OK +>b : Symbol(b, Decl(booleanAssignment.ts, 0, 3)) + +var b2:boolean; +>b2 : Symbol(b2, Decl(booleanAssignment.ts, 10, 3)) + +b = b2; // OK +>b : Symbol(b, Decl(booleanAssignment.ts, 0, 3)) +>b2 : Symbol(b2, Decl(booleanAssignment.ts, 10, 3)) + diff --git a/tests/baselines/reference/booleanAssignment.types b/tests/baselines/reference/booleanAssignment.types new file mode 100644 index 00000000000..8af64f59bb3 --- /dev/null +++ b/tests/baselines/reference/booleanAssignment.types @@ -0,0 +1,43 @@ +=== tests/cases/compiler/booleanAssignment.ts === +var b = new Boolean(); +>b : Boolean +>new Boolean() : Boolean +>Boolean : BooleanConstructor + +b = 1; // Error +>b = 1 : 1 +>b : Boolean +>1 : 1 + +b = "a"; // Error +>b = "a" : "a" +>b : Boolean +>"a" : "a" + +b = {}; // Error +>b = {} : {} +>b : Boolean +>{} : {} + +var o = {}; +>o : {} +>{} : {} + +o = b; // OK +>o = b : Boolean +>o : {} +>b : Boolean + +b = true; // OK +>b = true : true +>b : Boolean +>true : true + +var b2:boolean; +>b2 : boolean + +b = b2; // OK +>b = b2 : boolean +>b : Boolean +>b2 : boolean + diff --git a/tests/baselines/reference/breakInIterationOrSwitchStatement4.symbols b/tests/baselines/reference/breakInIterationOrSwitchStatement4.symbols new file mode 100644 index 00000000000..f7d0661c163 --- /dev/null +++ b/tests/baselines/reference/breakInIterationOrSwitchStatement4.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/breakInIterationOrSwitchStatement4.ts === +for (var i in something) { +>i : Symbol(i, Decl(breakInIterationOrSwitchStatement4.ts, 0, 8)) + + break; +} diff --git a/tests/baselines/reference/breakInIterationOrSwitchStatement4.types b/tests/baselines/reference/breakInIterationOrSwitchStatement4.types new file mode 100644 index 00000000000..e38a44a3abb --- /dev/null +++ b/tests/baselines/reference/breakInIterationOrSwitchStatement4.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/breakInIterationOrSwitchStatement4.ts === +for (var i in something) { +>i : string +>something : any + + break; +} diff --git a/tests/baselines/reference/breakNotInIterationOrSwitchStatement1.symbols b/tests/baselines/reference/breakNotInIterationOrSwitchStatement1.symbols new file mode 100644 index 00000000000..2537ee25771 --- /dev/null +++ b/tests/baselines/reference/breakNotInIterationOrSwitchStatement1.symbols @@ -0,0 +1,3 @@ +=== tests/cases/compiler/breakNotInIterationOrSwitchStatement1.ts === +break; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/breakNotInIterationOrSwitchStatement1.types b/tests/baselines/reference/breakNotInIterationOrSwitchStatement1.types new file mode 100644 index 00000000000..2537ee25771 --- /dev/null +++ b/tests/baselines/reference/breakNotInIterationOrSwitchStatement1.types @@ -0,0 +1,3 @@ +=== tests/cases/compiler/breakNotInIterationOrSwitchStatement1.ts === +break; +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/breakNotInIterationOrSwitchStatement2.symbols b/tests/baselines/reference/breakNotInIterationOrSwitchStatement2.symbols new file mode 100644 index 00000000000..2c9d766ee46 --- /dev/null +++ b/tests/baselines/reference/breakNotInIterationOrSwitchStatement2.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/breakNotInIterationOrSwitchStatement2.ts === +while (true) { + function f() { +>f : Symbol(f, Decl(breakNotInIterationOrSwitchStatement2.ts, 0, 14)) + + break; + } +} diff --git a/tests/baselines/reference/breakNotInIterationOrSwitchStatement2.types b/tests/baselines/reference/breakNotInIterationOrSwitchStatement2.types new file mode 100644 index 00000000000..3b471271884 --- /dev/null +++ b/tests/baselines/reference/breakNotInIterationOrSwitchStatement2.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/breakNotInIterationOrSwitchStatement2.ts === +while (true) { +>true : true + + function f() { +>f : () => void + + break; + } +} diff --git a/tests/baselines/reference/breakTarget5.symbols b/tests/baselines/reference/breakTarget5.symbols new file mode 100644 index 00000000000..ffdfc87eff1 --- /dev/null +++ b/tests/baselines/reference/breakTarget5.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/breakTarget5.ts === +target: +while (true) { + function f() { +>f : Symbol(f, Decl(breakTarget5.ts, 1, 14)) + + while (true) { + break target; + } + } +} diff --git a/tests/baselines/reference/breakTarget5.types b/tests/baselines/reference/breakTarget5.types new file mode 100644 index 00000000000..efb5703e0ee --- /dev/null +++ b/tests/baselines/reference/breakTarget5.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/breakTarget5.ts === +target: +>target : any + +while (true) { +>true : true + + function f() { +>f : () => void + + while (true) { +>true : true + + break target; +>target : any + } + } +} diff --git a/tests/baselines/reference/breakTarget6.symbols b/tests/baselines/reference/breakTarget6.symbols new file mode 100644 index 00000000000..2c5ebfae3f7 --- /dev/null +++ b/tests/baselines/reference/breakTarget6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/breakTarget6.ts === +while (true) { +No type information for this code. break target; +No type information for this code.} +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/breakTarget6.types b/tests/baselines/reference/breakTarget6.types new file mode 100644 index 00000000000..afc1e917acd --- /dev/null +++ b/tests/baselines/reference/breakTarget6.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/breakTarget6.ts === +while (true) { +>true : true + + break target; +>target : any +} diff --git a/tests/baselines/reference/cachedModuleResolution6.symbols b/tests/baselines/reference/cachedModuleResolution6.symbols new file mode 100644 index 00000000000..87948f86b0b --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution6.symbols @@ -0,0 +1,8 @@ +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution6.types b/tests/baselines/reference/cachedModuleResolution6.types new file mode 100644 index 00000000000..638d2aefb69 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution6.types @@ -0,0 +1,8 @@ +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : any + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : any + diff --git a/tests/baselines/reference/cachedModuleResolution7.symbols b/tests/baselines/reference/cachedModuleResolution7.symbols new file mode 100644 index 00000000000..b6a0ad02ff5 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution7.symbols @@ -0,0 +1,8 @@ +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution7.types b/tests/baselines/reference/cachedModuleResolution7.types new file mode 100644 index 00000000000..3ed9aea6856 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution7.types @@ -0,0 +1,8 @@ +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : any + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : any + diff --git a/tests/baselines/reference/cachedModuleResolution8.symbols b/tests/baselines/reference/cachedModuleResolution8.symbols new file mode 100644 index 00000000000..87948f86b0b --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution8.symbols @@ -0,0 +1,8 @@ +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution8.types b/tests/baselines/reference/cachedModuleResolution8.types new file mode 100644 index 00000000000..638d2aefb69 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution8.types @@ -0,0 +1,8 @@ +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : any + +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : any + diff --git a/tests/baselines/reference/cachedModuleResolution9.symbols b/tests/baselines/reference/cachedModuleResolution9.symbols new file mode 100644 index 00000000000..acf7ef51142 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution9.symbols @@ -0,0 +1,9 @@ +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(lib.ts, 0, 8)) + + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : Symbol(x, Decl(app.ts, 0, 8)) + diff --git a/tests/baselines/reference/cachedModuleResolution9.types b/tests/baselines/reference/cachedModuleResolution9.types new file mode 100644 index 00000000000..8a14f19e1b1 --- /dev/null +++ b/tests/baselines/reference/cachedModuleResolution9.types @@ -0,0 +1,9 @@ +=== /a/b/c/lib.ts === +import {x} from "foo"; +>x : any + + +=== /a/b/c/d/e/app.ts === +import {x} from "foo"; +>x : any + diff --git a/tests/baselines/reference/callConstructAssignment.symbols b/tests/baselines/reference/callConstructAssignment.symbols new file mode 100644 index 00000000000..8780e6466af --- /dev/null +++ b/tests/baselines/reference/callConstructAssignment.symbols @@ -0,0 +1,15 @@ +=== tests/cases/compiler/callConstructAssignment.ts === +var foo:{ ( ):void; } +>foo : Symbol(foo, Decl(callConstructAssignment.ts, 0, 3)) + +var bar:{ new ( ):any; } +>bar : Symbol(bar, Decl(callConstructAssignment.ts, 2, 3)) + +foo = bar; // error +>foo : Symbol(foo, Decl(callConstructAssignment.ts, 0, 3)) +>bar : Symbol(bar, Decl(callConstructAssignment.ts, 2, 3)) + +bar = foo; // error +>bar : Symbol(bar, Decl(callConstructAssignment.ts, 2, 3)) +>foo : Symbol(foo, Decl(callConstructAssignment.ts, 0, 3)) + diff --git a/tests/baselines/reference/callConstructAssignment.types b/tests/baselines/reference/callConstructAssignment.types new file mode 100644 index 00000000000..c0708ed33cc --- /dev/null +++ b/tests/baselines/reference/callConstructAssignment.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/callConstructAssignment.ts === +var foo:{ ( ):void; } +>foo : () => void + +var bar:{ new ( ):any; } +>bar : new () => any + +foo = bar; // error +>foo = bar : new () => any +>foo : () => void +>bar : new () => any + +bar = foo; // error +>bar = foo : () => void +>bar : new () => any +>foo : () => void + diff --git a/tests/baselines/reference/callExpressionWithMissingTypeArgument1.symbols b/tests/baselines/reference/callExpressionWithMissingTypeArgument1.symbols new file mode 100644 index 00000000000..b794252928d --- /dev/null +++ b/tests/baselines/reference/callExpressionWithMissingTypeArgument1.symbols @@ -0,0 +1,3 @@ +=== tests/cases/compiler/callExpressionWithMissingTypeArgument1.ts === +Foo(); +No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/callExpressionWithMissingTypeArgument1.types b/tests/baselines/reference/callExpressionWithMissingTypeArgument1.types new file mode 100644 index 00000000000..bd07bb31cac --- /dev/null +++ b/tests/baselines/reference/callExpressionWithMissingTypeArgument1.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/callExpressionWithMissingTypeArgument1.ts === +Foo(); +>Foo() : any +>Foo : any +>a : No type information available! +> : No type information available! +>b : No type information available! + diff --git a/tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.symbols b/tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.symbols new file mode 100644 index 00000000000..9eb87881f44 --- /dev/null +++ b/tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.symbols @@ -0,0 +1,172 @@ +=== tests/cases/conformance/types/typeParameters/typeArgumentLists/callGenericFunctionWithIncorrectNumberOfTypeArguments.ts === +// type parameter lists must exactly match type argument lists +// all of these invocations are errors + +function f(x: T, y: U): T { return null; } +>f : Symbol(f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 0, 0)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 3, 11)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 3, 13)) +>x : Symbol(x, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 3, 17)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 3, 11)) +>y : Symbol(y, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 3, 22)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 3, 13)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 3, 11)) + +var r1 = f(1, ''); +>r1 : Symbol(r1, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 4, 3)) +>f : Symbol(f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 0, 0)) + +var r1b = f(1, ''); +>r1b : Symbol(r1b, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 5, 3)) +>f : Symbol(f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 0, 0)) + +var f2 = (x: T, y: U): T => { return null; } +>f2 : Symbol(f2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 3)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 10)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 12)) +>x : Symbol(x, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 16)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 10)) +>y : Symbol(y, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 21)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 12)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 10)) + +var r2 = f2(1, ''); +>r2 : Symbol(r2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 8, 3)) +>f2 : Symbol(f2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 3)) + +var r2b = f2(1, ''); +>r2b : Symbol(r2b, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 9, 3)) +>f2 : Symbol(f2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 7, 3)) + +var f3: { (x: T, y: U): T; } +>f3 : Symbol(f3, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 3)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 11)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 13)) +>x : Symbol(x, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 17)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 11)) +>y : Symbol(y, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 22)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 13)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 11)) + +var r3 = f3(1, ''); +>r3 : Symbol(r3, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 12, 3)) +>f3 : Symbol(f3, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 3)) + +var r3b = f3(1, ''); +>r3b : Symbol(r3b, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 13, 3)) +>f3 : Symbol(f3, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 11, 3)) + +class C { +>C : Symbol(C, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 13, 44)) + + f(x: T, y: U): T { +>f : Symbol(C.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 15, 9)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 16, 6)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 16, 8)) +>x : Symbol(x, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 16, 12)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 16, 6)) +>y : Symbol(y, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 16, 17)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 16, 8)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 16, 6)) + + return null; + } +} +var r4 = (new C()).f(1, ''); +>r4 : Symbol(r4, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 20, 3)) +>(new C()).f : Symbol(C.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 15, 9)) +>C : Symbol(C, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 13, 44)) +>f : Symbol(C.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 15, 9)) + +var r4b = (new C()).f(1, ''); +>r4b : Symbol(r4b, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 21, 3)) +>(new C()).f : Symbol(C.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 15, 9)) +>C : Symbol(C, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 13, 44)) +>f : Symbol(C.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 15, 9)) + +interface I { +>I : Symbol(I, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 21, 53)) + + f(x: T, y: U): T; +>f : Symbol(I.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 23, 13)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 24, 6)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 24, 8)) +>x : Symbol(x, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 24, 12)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 24, 6)) +>y : Symbol(y, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 24, 17)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 24, 8)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 24, 6)) +} +var i: I; +>i : Symbol(i, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 26, 3)) +>I : Symbol(I, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 21, 53)) + +var r5 = i.f(1, ''); +>r5 : Symbol(r5, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 27, 3)) +>i.f : Symbol(I.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 23, 13)) +>i : Symbol(i, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 26, 3)) +>f : Symbol(I.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 23, 13)) + +var r5b = i.f(1, ''); +>r5b : Symbol(r5b, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 28, 3)) +>i.f : Symbol(I.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 23, 13)) +>i : Symbol(i, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 26, 3)) +>f : Symbol(I.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 23, 13)) + +class C2 { +>C2 : Symbol(C2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 28, 45)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 9)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 11)) + + f(x: T, y: U): T { +>f : Symbol(C2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 16)) +>x : Symbol(x, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 31, 6)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 9)) +>y : Symbol(y, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 31, 11)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 11)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 9)) + + return null; + } +} +var r6 = (new C2()).f(1, ''); +>r6 : Symbol(r6, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 35, 3)) +>(new C2()).f : Symbol(C2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 16)) +>C2 : Symbol(C2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 28, 45)) +>f : Symbol(C2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 16)) + +var r6b = (new C2()).f(1, ''); +>r6b : Symbol(r6b, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 36, 3)) +>(new C2()).f : Symbol(C2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 16)) +>C2 : Symbol(C2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 28, 45)) +>f : Symbol(C2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 30, 16)) + +interface I2 { +>I2 : Symbol(I2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 36, 54)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 13)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 15)) + + f(x: T, y: U): T; +>f : Symbol(I2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 20)) +>x : Symbol(x, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 39, 6)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 13)) +>y : Symbol(y, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 39, 11)) +>U : Symbol(U, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 15)) +>T : Symbol(T, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 13)) +} +var i2: I2; +>i2 : Symbol(i2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 41, 3)) +>I2 : Symbol(I2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 36, 54)) + +var r7 = i2.f(1, ''); +>r7 : Symbol(r7, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 42, 3)) +>i2.f : Symbol(I2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 20)) +>i2 : Symbol(i2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 41, 3)) +>f : Symbol(I2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 20)) + +var r7b = i2.f(1, ''); +>r7b : Symbol(r7b, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 43, 3)) +>i2.f : Symbol(I2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 20)) +>i2 : Symbol(i2, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 41, 3)) +>f : Symbol(I2.f, Decl(callGenericFunctionWithIncorrectNumberOfTypeArguments.ts, 38, 20)) + diff --git a/tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.types b/tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.types new file mode 100644 index 00000000000..da8a4a339b5 --- /dev/null +++ b/tests/baselines/reference/callGenericFunctionWithIncorrectNumberOfTypeArguments.types @@ -0,0 +1,227 @@ +=== tests/cases/conformance/types/typeParameters/typeArgumentLists/callGenericFunctionWithIncorrectNumberOfTypeArguments.ts === +// type parameter lists must exactly match type argument lists +// all of these invocations are errors + +function f(x: T, y: U): T { return null; } +>f : (x: T, y: U) => T +>T : T +>U : U +>x : T +>T : T +>y : U +>U : U +>T : T +>null : null + +var r1 = f(1, ''); +>r1 : any +>f(1, '') : any +>f : (x: T, y: U) => T +>1 : 1 +>'' : "" + +var r1b = f(1, ''); +>r1b : any +>f(1, '') : any +>f : (x: T, y: U) => T +>1 : 1 +>'' : "" + +var f2 = (x: T, y: U): T => { return null; } +>f2 : (x: T, y: U) => T +>(x: T, y: U): T => { return null; } : (x: T, y: U) => T +>T : T +>U : U +>x : T +>T : T +>y : U +>U : U +>T : T +>null : null + +var r2 = f2(1, ''); +>r2 : any +>f2(1, '') : any +>f2 : (x: T, y: U) => T +>1 : 1 +>'' : "" + +var r2b = f2(1, ''); +>r2b : any +>f2(1, '') : any +>f2 : (x: T, y: U) => T +>1 : 1 +>'' : "" + +var f3: { (x: T, y: U): T; } +>f3 : (x: T, y: U) => T +>T : T +>U : U +>x : T +>T : T +>y : U +>U : U +>T : T + +var r3 = f3(1, ''); +>r3 : any +>f3(1, '') : any +>f3 : (x: T, y: U) => T +>1 : 1 +>'' : "" + +var r3b = f3(1, ''); +>r3b : any +>f3(1, '') : any +>f3 : (x: T, y: U) => T +>1 : 1 +>'' : "" + +class C { +>C : C + + f(x: T, y: U): T { +>f : (x: T, y: U) => T +>T : T +>U : U +>x : T +>T : T +>y : U +>U : U +>T : T + + return null; +>null : null + } +} +var r4 = (new C()).f(1, ''); +>r4 : any +>(new C()).f(1, '') : any +>(new C()).f : (x: T, y: U) => T +>(new C()) : C +>new C() : C +>C : typeof C +>f : (x: T, y: U) => T +>1 : 1 +>'' : "" + +var r4b = (new C()).f(1, ''); +>r4b : any +>(new C()).f(1, '') : any +>(new C()).f : (x: T, y: U) => T +>(new C()) : C +>new C() : C +>C : typeof C +>f : (x: T, y: U) => T +>1 : 1 +>'' : "" + +interface I { +>I : I + + f(x: T, y: U): T; +>f : (x: T, y: U) => T +>T : T +>U : U +>x : T +>T : T +>y : U +>U : U +>T : T +} +var i: I; +>i : I +>I : I + +var r5 = i.f(1, ''); +>r5 : any +>i.f(1, '') : any +>i.f : (x: T, y: U) => T +>i : I +>f : (x: T, y: U) => T +>1 : 1 +>'' : "" + +var r5b = i.f(1, ''); +>r5b : any +>i.f(1, '') : any +>i.f : (x: T, y: U) => T +>i : I +>f : (x: T, y: U) => T +>1 : 1 +>'' : "" + +class C2 { +>C2 : C2 +>T : T +>U : U + + f(x: T, y: U): T { +>f : (x: T, y: U) => T +>x : T +>T : T +>y : U +>U : U +>T : T + + return null; +>null : null + } +} +var r6 = (new C2()).f(1, ''); +>r6 : {} +>(new C2()).f(1, '') : {} +>(new C2()).f : (x: {}, y: {}) => {} +>(new C2()) : C2<{}, {}> +>new C2() : C2<{}, {}> +>C2 : typeof C2 +>f : (x: {}, y: {}) => {} +>1 : 1 +>'' : "" + +var r6b = (new C2()).f(1, ''); +>r6b : {} +>(new C2()).f(1, '') : {} +>(new C2()).f : (x: {}, y: {}) => {} +>(new C2()) : C2<{}, {}> +>new C2() : C2<{}, {}> +>C2 : typeof C2 +>f : (x: {}, y: {}) => {} +>1 : 1 +>'' : "" + +interface I2 { +>I2 : I2 +>T : T +>U : U + + f(x: T, y: U): T; +>f : (x: T, y: U) => T +>x : T +>T : T +>y : U +>U : U +>T : T +} +var i2: I2; +>i2 : I2 +>I2 : I2 + +var r7 = i2.f(1, ''); +>r7 : number +>i2.f(1, '') : number +>i2.f : (x: number, y: string) => number +>i2 : I2 +>f : (x: number, y: string) => number +>1 : 1 +>'' : "" + +var r7b = i2.f(1, ''); +>r7b : number +>i2.f(1, '') : number +>i2.f : (x: number, y: string) => number +>i2 : I2 +>f : (x: number, y: string) => number +>1 : 1 +>'' : "" + diff --git a/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.symbols b/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.symbols new file mode 100644 index 00000000000..4bfa3655841 --- /dev/null +++ b/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.symbols @@ -0,0 +1,108 @@ +=== tests/cases/conformance/types/typeParameters/typeArgumentLists/callNonGenericFunctionWithTypeArguments.ts === +// it is always illegal to provide type arguments to a non-generic function +// all invocations here are illegal + +function f(x: number) { return null; } +>f : Symbol(f, Decl(callNonGenericFunctionWithTypeArguments.ts, 0, 0)) +>x : Symbol(x, Decl(callNonGenericFunctionWithTypeArguments.ts, 3, 11)) + +var r = f(1); +>r : Symbol(r, Decl(callNonGenericFunctionWithTypeArguments.ts, 4, 3)) +>f : Symbol(f, Decl(callNonGenericFunctionWithTypeArguments.ts, 0, 0)) + +var f2 = (x: number) => { return null; } +>f2 : Symbol(f2, Decl(callNonGenericFunctionWithTypeArguments.ts, 6, 3)) +>x : Symbol(x, Decl(callNonGenericFunctionWithTypeArguments.ts, 6, 10)) + +var r2 = f2(1); +>r2 : Symbol(r2, Decl(callNonGenericFunctionWithTypeArguments.ts, 7, 3)) +>f2 : Symbol(f2, Decl(callNonGenericFunctionWithTypeArguments.ts, 6, 3)) + +var f3: { (x: number): any; } +>f3 : Symbol(f3, Decl(callNonGenericFunctionWithTypeArguments.ts, 9, 3)) +>x : Symbol(x, Decl(callNonGenericFunctionWithTypeArguments.ts, 9, 11)) + +var r3 = f3(1); +>r3 : Symbol(r3, Decl(callNonGenericFunctionWithTypeArguments.ts, 10, 3)) +>f3 : Symbol(f3, Decl(callNonGenericFunctionWithTypeArguments.ts, 9, 3)) + +class C { +>C : Symbol(C, Decl(callNonGenericFunctionWithTypeArguments.ts, 10, 23)) + + f(x: number) { +>f : Symbol(C.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 12, 9)) +>x : Symbol(x, Decl(callNonGenericFunctionWithTypeArguments.ts, 13, 6)) + + return null; + } +} +var r4 = (new C()).f(1); +>r4 : Symbol(r4, Decl(callNonGenericFunctionWithTypeArguments.ts, 17, 3)) +>(new C()).f : Symbol(C.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 12, 9)) +>C : Symbol(C, Decl(callNonGenericFunctionWithTypeArguments.ts, 10, 23)) +>f : Symbol(C.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 12, 9)) + +interface I { +>I : Symbol(I, Decl(callNonGenericFunctionWithTypeArguments.ts, 17, 32)) + + f(x: number): any; +>f : Symbol(I.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 19, 13)) +>x : Symbol(x, Decl(callNonGenericFunctionWithTypeArguments.ts, 20, 6)) +} +var i: I; +>i : Symbol(i, Decl(callNonGenericFunctionWithTypeArguments.ts, 22, 3)) +>I : Symbol(I, Decl(callNonGenericFunctionWithTypeArguments.ts, 17, 32)) + +var r5 = i.f(1); +>r5 : Symbol(r5, Decl(callNonGenericFunctionWithTypeArguments.ts, 23, 3)) +>i.f : Symbol(I.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 19, 13)) +>i : Symbol(i, Decl(callNonGenericFunctionWithTypeArguments.ts, 22, 3)) +>f : Symbol(I.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 19, 13)) + +class C2 { +>C2 : Symbol(C2, Decl(callNonGenericFunctionWithTypeArguments.ts, 23, 24)) + + f(x: number) { +>f : Symbol(C2.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 25, 10)) +>x : Symbol(x, Decl(callNonGenericFunctionWithTypeArguments.ts, 26, 6)) + + return null; + } +} +var r6 = (new C2()).f(1); +>r6 : Symbol(r6, Decl(callNonGenericFunctionWithTypeArguments.ts, 30, 3)) +>(new C2()).f : Symbol(C2.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 25, 10)) +>C2 : Symbol(C2, Decl(callNonGenericFunctionWithTypeArguments.ts, 23, 24)) +>f : Symbol(C2.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 25, 10)) + +interface I2 { +>I2 : Symbol(I2, Decl(callNonGenericFunctionWithTypeArguments.ts, 30, 33)) + + f(x: number); +>f : Symbol(I2.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 32, 14)) +>x : Symbol(x, Decl(callNonGenericFunctionWithTypeArguments.ts, 33, 6)) +} +var i2: I2; +>i2 : Symbol(i2, Decl(callNonGenericFunctionWithTypeArguments.ts, 35, 3)) +>I2 : Symbol(I2, Decl(callNonGenericFunctionWithTypeArguments.ts, 30, 33)) + +var r7 = i2.f(1); +>r7 : Symbol(r7, Decl(callNonGenericFunctionWithTypeArguments.ts, 36, 3)) +>i2.f : Symbol(I2.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 32, 14)) +>i2 : Symbol(i2, Decl(callNonGenericFunctionWithTypeArguments.ts, 35, 3)) +>f : Symbol(I2.f, Decl(callNonGenericFunctionWithTypeArguments.ts, 32, 14)) + +var a; +>a : Symbol(a, Decl(callNonGenericFunctionWithTypeArguments.ts, 38, 3)) + +var r8 = a(); +>r8 : Symbol(r8, Decl(callNonGenericFunctionWithTypeArguments.ts, 39, 3), Decl(callNonGenericFunctionWithTypeArguments.ts, 42, 3)) +>a : Symbol(a, Decl(callNonGenericFunctionWithTypeArguments.ts, 38, 3)) + +var a2: any; +>a2 : Symbol(a2, Decl(callNonGenericFunctionWithTypeArguments.ts, 41, 3)) + +var r8 = a2(); +>r8 : Symbol(r8, Decl(callNonGenericFunctionWithTypeArguments.ts, 39, 3), Decl(callNonGenericFunctionWithTypeArguments.ts, 42, 3)) +>a2 : Symbol(a2, Decl(callNonGenericFunctionWithTypeArguments.ts, 41, 3)) + diff --git a/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.types b/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.types new file mode 100644 index 00000000000..b7155b564ef --- /dev/null +++ b/tests/baselines/reference/callNonGenericFunctionWithTypeArguments.types @@ -0,0 +1,133 @@ +=== tests/cases/conformance/types/typeParameters/typeArgumentLists/callNonGenericFunctionWithTypeArguments.ts === +// it is always illegal to provide type arguments to a non-generic function +// all invocations here are illegal + +function f(x: number) { return null; } +>f : (x: number) => any +>x : number +>null : null + +var r = f(1); +>r : any +>f(1) : any +>f : (x: number) => any +>1 : 1 + +var f2 = (x: number) => { return null; } +>f2 : (x: number) => any +>(x: number) => { return null; } : (x: number) => any +>x : number +>null : null + +var r2 = f2(1); +>r2 : any +>f2(1) : any +>f2 : (x: number) => any +>1 : 1 + +var f3: { (x: number): any; } +>f3 : (x: number) => any +>x : number + +var r3 = f3(1); +>r3 : any +>f3(1) : any +>f3 : (x: number) => any +>1 : 1 + +class C { +>C : C + + f(x: number) { +>f : (x: number) => any +>x : number + + return null; +>null : null + } +} +var r4 = (new C()).f(1); +>r4 : any +>(new C()).f(1) : any +>(new C()).f : (x: number) => any +>(new C()) : C +>new C() : C +>C : typeof C +>f : (x: number) => any +>1 : 1 + +interface I { +>I : I + + f(x: number): any; +>f : (x: number) => any +>x : number +} +var i: I; +>i : I +>I : I + +var r5 = i.f(1); +>r5 : any +>i.f(1) : any +>i.f : (x: number) => any +>i : I +>f : (x: number) => any +>1 : 1 + +class C2 { +>C2 : C2 + + f(x: number) { +>f : (x: number) => any +>x : number + + return null; +>null : null + } +} +var r6 = (new C2()).f(1); +>r6 : any +>(new C2()).f(1) : any +>(new C2()).f : (x: number) => any +>(new C2()) : C2 +>new C2() : C2 +>C2 : typeof C2 +>f : (x: number) => any +>1 : 1 + +interface I2 { +>I2 : I2 + + f(x: number); +>f : (x: number) => any +>x : number +} +var i2: I2; +>i2 : I2 +>I2 : I2 + +var r7 = i2.f(1); +>r7 : any +>i2.f(1) : any +>i2.f : (x: number) => any +>i2 : I2 +>f : (x: number) => any +>1 : 1 + +var a; +>a : any + +var r8 = a(); +>r8 : any +>a() : any +>a : any + +var a2: any; +>a2 : any + +var r8 = a2(); +>r8 : any +>a2() : any +>a2 : any + diff --git a/tests/baselines/reference/callOnClass.symbols b/tests/baselines/reference/callOnClass.symbols new file mode 100644 index 00000000000..49fdbc40592 --- /dev/null +++ b/tests/baselines/reference/callOnClass.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/callOnClass.ts === +class C { } +>C : Symbol(C, Decl(callOnClass.ts, 0, 0)) + +var c = C(); +>c : Symbol(c, Decl(callOnClass.ts, 1, 3)) +>C : Symbol(C, Decl(callOnClass.ts, 0, 0)) + + diff --git a/tests/baselines/reference/callOnClass.types b/tests/baselines/reference/callOnClass.types new file mode 100644 index 00000000000..8b57fdb764e --- /dev/null +++ b/tests/baselines/reference/callOnClass.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/callOnClass.ts === +class C { } +>C : C + +var c = C(); +>c : any +>C() : any +>C : typeof C + + diff --git a/tests/baselines/reference/callOnInstance.symbols b/tests/baselines/reference/callOnInstance.symbols new file mode 100644 index 00000000000..1bf147805fd --- /dev/null +++ b/tests/baselines/reference/callOnInstance.symbols @@ -0,0 +1,23 @@ +=== tests/cases/compiler/callOnInstance.ts === +declare function D(): string; // error +>D : Symbol(D, Decl(callOnInstance.ts, 0, 0)) + +declare class D { constructor (value: number); } // error +>D : Symbol(D, Decl(callOnInstance.ts, 0, 29)) +>value : Symbol(value, Decl(callOnInstance.ts, 2, 31)) + +var s1: string = D(); // OK +>s1 : Symbol(s1, Decl(callOnInstance.ts, 4, 3)) +>D : Symbol(D, Decl(callOnInstance.ts, 0, 0)) + +var s2: string = (new D(1))(); +>s2 : Symbol(s2, Decl(callOnInstance.ts, 6, 3)) +>D : Symbol(D, Decl(callOnInstance.ts, 0, 0)) + +declare class C { constructor(value: number); } +>C : Symbol(C, Decl(callOnInstance.ts, 6, 30)) +>value : Symbol(value, Decl(callOnInstance.ts, 8, 30)) + +(new C(1))(); // Error for calling an instance +>C : Symbol(C, Decl(callOnInstance.ts, 6, 30)) + diff --git a/tests/baselines/reference/callOnInstance.types b/tests/baselines/reference/callOnInstance.types new file mode 100644 index 00000000000..c90954ded07 --- /dev/null +++ b/tests/baselines/reference/callOnInstance.types @@ -0,0 +1,32 @@ +=== tests/cases/compiler/callOnInstance.ts === +declare function D(): string; // error +>D : () => string + +declare class D { constructor (value: number); } // error +>D : D +>value : number + +var s1: string = D(); // OK +>s1 : string +>D() : string +>D : () => string + +var s2: string = (new D(1))(); +>s2 : string +>(new D(1))() : any +>(new D(1)) : any +>new D(1) : any +>D : () => string +>1 : 1 + +declare class C { constructor(value: number); } +>C : C +>value : number + +(new C(1))(); // Error for calling an instance +>(new C(1))() : any +>(new C(1)) : C +>new C(1) : C +>C : typeof C +>1 : 1 + diff --git a/tests/baselines/reference/callOverloadViaElementAccessExpression.symbols b/tests/baselines/reference/callOverloadViaElementAccessExpression.symbols new file mode 100644 index 00000000000..bad58e91cdd --- /dev/null +++ b/tests/baselines/reference/callOverloadViaElementAccessExpression.symbols @@ -0,0 +1,34 @@ +=== tests/cases/compiler/callOverloadViaElementAccessExpression.ts === +class C { +>C : Symbol(C, Decl(callOverloadViaElementAccessExpression.ts, 0, 0)) + + foo(x: number): number; +>foo : Symbol(C.foo, Decl(callOverloadViaElementAccessExpression.ts, 0, 9), Decl(callOverloadViaElementAccessExpression.ts, 1, 27), Decl(callOverloadViaElementAccessExpression.ts, 2, 27)) +>x : Symbol(x, Decl(callOverloadViaElementAccessExpression.ts, 1, 8)) + + foo(x: string): string; +>foo : Symbol(C.foo, Decl(callOverloadViaElementAccessExpression.ts, 0, 9), Decl(callOverloadViaElementAccessExpression.ts, 1, 27), Decl(callOverloadViaElementAccessExpression.ts, 2, 27)) +>x : Symbol(x, Decl(callOverloadViaElementAccessExpression.ts, 2, 8)) + + foo(x: any): any { +>foo : Symbol(C.foo, Decl(callOverloadViaElementAccessExpression.ts, 0, 9), Decl(callOverloadViaElementAccessExpression.ts, 1, 27), Decl(callOverloadViaElementAccessExpression.ts, 2, 27)) +>x : Symbol(x, Decl(callOverloadViaElementAccessExpression.ts, 3, 8)) + + return null; + } +} + +var c = new C(); +>c : Symbol(c, Decl(callOverloadViaElementAccessExpression.ts, 8, 3)) +>C : Symbol(C, Decl(callOverloadViaElementAccessExpression.ts, 0, 0)) + +var r: string = c['foo'](1); +>r : Symbol(r, Decl(callOverloadViaElementAccessExpression.ts, 9, 3)) +>c : Symbol(c, Decl(callOverloadViaElementAccessExpression.ts, 8, 3)) +>'foo' : Symbol(C.foo, Decl(callOverloadViaElementAccessExpression.ts, 0, 9), Decl(callOverloadViaElementAccessExpression.ts, 1, 27), Decl(callOverloadViaElementAccessExpression.ts, 2, 27)) + +var r2: number = c['foo'](''); +>r2 : Symbol(r2, Decl(callOverloadViaElementAccessExpression.ts, 10, 3)) +>c : Symbol(c, Decl(callOverloadViaElementAccessExpression.ts, 8, 3)) +>'foo' : Symbol(C.foo, Decl(callOverloadViaElementAccessExpression.ts, 0, 9), Decl(callOverloadViaElementAccessExpression.ts, 1, 27), Decl(callOverloadViaElementAccessExpression.ts, 2, 27)) + diff --git a/tests/baselines/reference/callOverloadViaElementAccessExpression.types b/tests/baselines/reference/callOverloadViaElementAccessExpression.types new file mode 100644 index 00000000000..a38777734cf --- /dev/null +++ b/tests/baselines/reference/callOverloadViaElementAccessExpression.types @@ -0,0 +1,42 @@ +=== tests/cases/compiler/callOverloadViaElementAccessExpression.ts === +class C { +>C : C + + foo(x: number): number; +>foo : { (x: number): number; (x: string): string; } +>x : number + + foo(x: string): string; +>foo : { (x: number): number; (x: string): string; } +>x : string + + foo(x: any): any { +>foo : { (x: number): number; (x: string): string; } +>x : any + + return null; +>null : null + } +} + +var c = new C(); +>c : C +>new C() : C +>C : typeof C + +var r: string = c['foo'](1); +>r : string +>c['foo'](1) : number +>c['foo'] : { (x: number): number; (x: string): string; } +>c : C +>'foo' : "foo" +>1 : 1 + +var r2: number = c['foo'](''); +>r2 : number +>c['foo']('') : string +>c['foo'] : { (x: number): number; (x: string): string; } +>c : C +>'foo' : "foo" +>'' : "" + diff --git a/tests/baselines/reference/callOverloads1.symbols b/tests/baselines/reference/callOverloads1.symbols new file mode 100644 index 00000000000..569e9dd024d --- /dev/null +++ b/tests/baselines/reference/callOverloads1.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/callOverloads1.ts === +class Foo { // error +>Foo : Symbol(Foo, Decl(callOverloads1.ts, 0, 0)) + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : Symbol(Foo.bar1, Decl(callOverloads1.ts, 0, 11)) + + constructor(x: any) { +>x : Symbol(x, Decl(callOverloads1.ts, 3, 16)) + + // WScript.Echo("Constructor function has executed"); + } +} + +function Foo(); // error +>Foo : Symbol(Foo, Decl(callOverloads1.ts, 6, 1)) + +function F1(s:string); +>F1 : Symbol(F1, Decl(callOverloads1.ts, 8, 15), Decl(callOverloads1.ts, 9, 22)) +>s : Symbol(s, Decl(callOverloads1.ts, 9, 12)) + +function F1(a:any) { return a;} +>F1 : Symbol(F1, Decl(callOverloads1.ts, 8, 15), Decl(callOverloads1.ts, 9, 22)) +>a : Symbol(a, Decl(callOverloads1.ts, 10, 12)) +>a : Symbol(a, Decl(callOverloads1.ts, 10, 12)) + +var f1 = new Foo("hey"); +>f1 : Symbol(f1, Decl(callOverloads1.ts, 12, 3)) +>Foo : Symbol(Foo, Decl(callOverloads1.ts, 0, 0)) + + +f1.bar1(); +>f1.bar1 : Symbol(Foo.bar1, Decl(callOverloads1.ts, 0, 11)) +>f1 : Symbol(f1, Decl(callOverloads1.ts, 12, 3)) +>bar1 : Symbol(Foo.bar1, Decl(callOverloads1.ts, 0, 11)) + +Foo(); +>Foo : Symbol(Foo, Decl(callOverloads1.ts, 0, 0)) + diff --git a/tests/baselines/reference/callOverloads1.types b/tests/baselines/reference/callOverloads1.types new file mode 100644 index 00000000000..4352f0eb6b3 --- /dev/null +++ b/tests/baselines/reference/callOverloads1.types @@ -0,0 +1,43 @@ +=== tests/cases/compiler/callOverloads1.ts === +class Foo { // error +>Foo : Foo + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : () => void + + constructor(x: any) { +>x : any + + // WScript.Echo("Constructor function has executed"); + } +} + +function Foo(); // error +>Foo : () => any + +function F1(s:string); +>F1 : (s: string) => any +>s : string + +function F1(a:any) { return a;} +>F1 : (s: string) => any +>a : any +>a : any + +var f1 = new Foo("hey"); +>f1 : Foo +>new Foo("hey") : Foo +>Foo : typeof Foo +>"hey" : "hey" + + +f1.bar1(); +>f1.bar1() : void +>f1.bar1 : () => void +>f1 : Foo +>bar1 : () => void + +Foo(); +>Foo() : any +>Foo : typeof Foo + diff --git a/tests/baselines/reference/callOverloads2.symbols b/tests/baselines/reference/callOverloads2.symbols new file mode 100644 index 00000000000..41e5bbff711 --- /dev/null +++ b/tests/baselines/reference/callOverloads2.symbols @@ -0,0 +1,49 @@ +=== tests/cases/compiler/callOverloads2.ts === +class Foo { // error +>Foo : Symbol(Foo, Decl(callOverloads2.ts, 0, 0)) + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : Symbol(Foo.bar1, Decl(callOverloads2.ts, 0, 11)) + + constructor(x: any) { +>x : Symbol(x, Decl(callOverloads2.ts, 3, 16)) + + // WScript.Echo("Constructor function has executed"); + } +} + +function Foo(); // error +>Foo : Symbol(Foo, Decl(callOverloads2.ts, 6, 1)) + +function F1(s:string) {return s;} // error +>F1 : Symbol(F1, Decl(callOverloads2.ts, 8, 15), Decl(callOverloads2.ts, 10, 33)) +>s : Symbol(s, Decl(callOverloads2.ts, 10, 12)) +>s : Symbol(s, Decl(callOverloads2.ts, 10, 12)) + +function F1(a:any) { return a;} // error +>F1 : Symbol(F1, Decl(callOverloads2.ts, 8, 15), Decl(callOverloads2.ts, 10, 33)) +>a : Symbol(a, Decl(callOverloads2.ts, 11, 12)) +>a : Symbol(a, Decl(callOverloads2.ts, 11, 12)) + +function Goo(s:string); // error - no implementation +>Goo : Symbol(Goo, Decl(callOverloads2.ts, 11, 31)) +>s : Symbol(s, Decl(callOverloads2.ts, 13, 13)) + +declare function Gar(s:String); // expect no error +>Gar : Symbol(Gar, Decl(callOverloads2.ts, 13, 23)) +>s : Symbol(s, Decl(callOverloads2.ts, 15, 21)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + +var f1 = new Foo("hey"); +>f1 : Symbol(f1, Decl(callOverloads2.ts, 17, 3)) +>Foo : Symbol(Foo, Decl(callOverloads2.ts, 0, 0)) + + +f1.bar1(); +>f1.bar1 : Symbol(Foo.bar1, Decl(callOverloads2.ts, 0, 11)) +>f1 : Symbol(f1, Decl(callOverloads2.ts, 17, 3)) +>bar1 : Symbol(Foo.bar1, Decl(callOverloads2.ts, 0, 11)) + +Foo(); +>Foo : Symbol(Foo, Decl(callOverloads2.ts, 0, 0)) + diff --git a/tests/baselines/reference/callOverloads2.types b/tests/baselines/reference/callOverloads2.types new file mode 100644 index 00000000000..5c8e68f29cd --- /dev/null +++ b/tests/baselines/reference/callOverloads2.types @@ -0,0 +1,53 @@ +=== tests/cases/compiler/callOverloads2.ts === +class Foo { // error +>Foo : Foo + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : () => void + + constructor(x: any) { +>x : any + + // WScript.Echo("Constructor function has executed"); + } +} + +function Foo(); // error +>Foo : () => any + +function F1(s:string) {return s;} // error +>F1 : (s: string) => string +>s : string +>s : string + +function F1(a:any) { return a;} // error +>F1 : (s: string) => string +>a : any +>a : any + +function Goo(s:string); // error - no implementation +>Goo : (s: string) => any +>s : string + +declare function Gar(s:String); // expect no error +>Gar : (s: String) => any +>s : String +>String : String + +var f1 = new Foo("hey"); +>f1 : Foo +>new Foo("hey") : Foo +>Foo : typeof Foo +>"hey" : "hey" + + +f1.bar1(); +>f1.bar1() : void +>f1.bar1 : () => void +>f1 : Foo +>bar1 : () => void + +Foo(); +>Foo() : any +>Foo : typeof Foo + diff --git a/tests/baselines/reference/callOverloads3.symbols b/tests/baselines/reference/callOverloads3.symbols new file mode 100644 index 00000000000..f694684402a --- /dev/null +++ b/tests/baselines/reference/callOverloads3.symbols @@ -0,0 +1,36 @@ +=== tests/cases/compiler/callOverloads3.ts === +function Foo():Foo; // error +>Foo : Symbol(Foo, Decl(callOverloads3.ts, 0, 0), Decl(callOverloads3.ts, 0, 19)) + +function Foo(s:string):Foo; // error +>Foo : Symbol(Foo, Decl(callOverloads3.ts, 0, 0), Decl(callOverloads3.ts, 0, 19)) +>s : Symbol(s, Decl(callOverloads3.ts, 1, 13)) + +class Foo { // error +>Foo : Symbol(Foo, Decl(callOverloads3.ts, 1, 27)) + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : Symbol(Foo.bar1, Decl(callOverloads3.ts, 2, 11)) + + constructor(x: any) { +>x : Symbol(x, Decl(callOverloads3.ts, 4, 16)) + + // WScript.Echo("Constructor function has executed"); + } +} +//class Foo(s: String); + +var f1 = new Foo("hey"); +>f1 : Symbol(f1, Decl(callOverloads3.ts, 10, 3)) +>Foo : Symbol(Foo, Decl(callOverloads3.ts, 0, 0), Decl(callOverloads3.ts, 0, 19)) + + +f1.bar1(); +>f1 : Symbol(f1, Decl(callOverloads3.ts, 10, 3)) + +Foo(); +>Foo : Symbol(Foo, Decl(callOverloads3.ts, 0, 0), Decl(callOverloads3.ts, 0, 19)) + +Foo("s"); +>Foo : Symbol(Foo, Decl(callOverloads3.ts, 0, 0), Decl(callOverloads3.ts, 0, 19)) + diff --git a/tests/baselines/reference/callOverloads3.types b/tests/baselines/reference/callOverloads3.types new file mode 100644 index 00000000000..f8717534cae --- /dev/null +++ b/tests/baselines/reference/callOverloads3.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/callOverloads3.ts === +function Foo():Foo; // error +>Foo : { (): any; (s: string): any; } +>Foo : No type information available! + +function Foo(s:string):Foo; // error +>Foo : { (): any; (s: string): any; } +>s : string +>Foo : No type information available! + +class Foo { // error +>Foo : Foo + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : () => void + + constructor(x: any) { +>x : any + + // WScript.Echo("Constructor function has executed"); + } +} +//class Foo(s: String); + +var f1 = new Foo("hey"); +>f1 : any +>new Foo("hey") : any +>Foo : { (): any; (s: string): any; } +>"hey" : "hey" + + +f1.bar1(); +>f1.bar1() : any +>f1.bar1 : any +>f1 : any +>bar1 : any + +Foo(); +>Foo() : any +>Foo : { (): any; (s: string): any; } + +Foo("s"); +>Foo("s") : any +>Foo : { (): any; (s: string): any; } +>"s" : "s" + diff --git a/tests/baselines/reference/callOverloads4.symbols b/tests/baselines/reference/callOverloads4.symbols new file mode 100644 index 00000000000..2d898dbdbcc --- /dev/null +++ b/tests/baselines/reference/callOverloads4.symbols @@ -0,0 +1,38 @@ +=== tests/cases/compiler/callOverloads4.ts === +function Foo():Foo; // error +>Foo : Symbol(Foo, Decl(callOverloads4.ts, 0, 0), Decl(callOverloads4.ts, 0, 19)) + +function Foo(s:string):Foo; // error +>Foo : Symbol(Foo, Decl(callOverloads4.ts, 0, 0), Decl(callOverloads4.ts, 0, 19)) +>s : Symbol(s, Decl(callOverloads4.ts, 1, 13)) + +class Foo { // error +>Foo : Symbol(Foo, Decl(callOverloads4.ts, 1, 27)) + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : Symbol(Foo.bar1, Decl(callOverloads4.ts, 2, 11)) + + constructor(s: string); +>s : Symbol(s, Decl(callOverloads4.ts, 4, 16)) + + constructor(x: any) { +>x : Symbol(x, Decl(callOverloads4.ts, 5, 16)) + + // WScript.Echo("Constructor function has executed"); + } +} + +var f1 = new Foo("hey"); +>f1 : Symbol(f1, Decl(callOverloads4.ts, 10, 3)) +>Foo : Symbol(Foo, Decl(callOverloads4.ts, 0, 0), Decl(callOverloads4.ts, 0, 19)) + + +f1.bar1(); +>f1 : Symbol(f1, Decl(callOverloads4.ts, 10, 3)) + +Foo(); +>Foo : Symbol(Foo, Decl(callOverloads4.ts, 0, 0), Decl(callOverloads4.ts, 0, 19)) + +Foo("s"); +>Foo : Symbol(Foo, Decl(callOverloads4.ts, 0, 0), Decl(callOverloads4.ts, 0, 19)) + diff --git a/tests/baselines/reference/callOverloads4.types b/tests/baselines/reference/callOverloads4.types new file mode 100644 index 00000000000..60d8ced5d1d --- /dev/null +++ b/tests/baselines/reference/callOverloads4.types @@ -0,0 +1,48 @@ +=== tests/cases/compiler/callOverloads4.ts === +function Foo():Foo; // error +>Foo : { (): any; (s: string): any; } +>Foo : No type information available! + +function Foo(s:string):Foo; // error +>Foo : { (): any; (s: string): any; } +>s : string +>Foo : No type information available! + +class Foo { // error +>Foo : Foo + + bar1() { /*WScript.Echo("bar1");*/ } +>bar1 : () => void + + constructor(s: string); +>s : string + + constructor(x: any) { +>x : any + + // WScript.Echo("Constructor function has executed"); + } +} + +var f1 = new Foo("hey"); +>f1 : any +>new Foo("hey") : any +>Foo : { (): any; (s: string): any; } +>"hey" : "hey" + + +f1.bar1(); +>f1.bar1() : any +>f1.bar1 : any +>f1 : any +>bar1 : any + +Foo(); +>Foo() : any +>Foo : { (): any; (s: string): any; } + +Foo("s"); +>Foo("s") : any +>Foo : { (): any; (s: string): any; } +>"s" : "s" + diff --git a/tests/baselines/reference/callOverloads5.symbols b/tests/baselines/reference/callOverloads5.symbols new file mode 100644 index 00000000000..0f63d3edf06 --- /dev/null +++ b/tests/baselines/reference/callOverloads5.symbols @@ -0,0 +1,45 @@ +=== tests/cases/compiler/callOverloads5.ts === +function Foo():Foo; // error +>Foo : Symbol(Foo, Decl(callOverloads5.ts, 0, 0), Decl(callOverloads5.ts, 0, 19)) + +function Foo(s:string):Foo; // error +>Foo : Symbol(Foo, Decl(callOverloads5.ts, 0, 0), Decl(callOverloads5.ts, 0, 19)) +>s : Symbol(s, Decl(callOverloads5.ts, 1, 13)) + +class Foo { // error +>Foo : Symbol(Foo, Decl(callOverloads5.ts, 1, 27)) + + bar1(s:string); +>bar1 : Symbol(Foo.bar1, Decl(callOverloads5.ts, 2, 11), Decl(callOverloads5.ts, 3, 16), Decl(callOverloads5.ts, 4, 16)) +>s : Symbol(s, Decl(callOverloads5.ts, 3, 6)) + + bar1(n:number); +>bar1 : Symbol(Foo.bar1, Decl(callOverloads5.ts, 2, 11), Decl(callOverloads5.ts, 3, 16), Decl(callOverloads5.ts, 4, 16)) +>n : Symbol(n, Decl(callOverloads5.ts, 4, 6)) + + bar1(a:any) { /*WScript.Echo(a);*/ } +>bar1 : Symbol(Foo.bar1, Decl(callOverloads5.ts, 2, 11), Decl(callOverloads5.ts, 3, 16), Decl(callOverloads5.ts, 4, 16)) +>a : Symbol(a, Decl(callOverloads5.ts, 5, 9)) + + constructor(x: any) { +>x : Symbol(x, Decl(callOverloads5.ts, 6, 16)) + + // WScript.Echo("Constructor function has executed"); + } +} +//class Foo(s: String); + +var f1 = new Foo("hey"); +>f1 : Symbol(f1, Decl(callOverloads5.ts, 12, 3)) +>Foo : Symbol(Foo, Decl(callOverloads5.ts, 0, 0), Decl(callOverloads5.ts, 0, 19)) + + +f1.bar1("a"); +>f1 : Symbol(f1, Decl(callOverloads5.ts, 12, 3)) + +Foo(); +>Foo : Symbol(Foo, Decl(callOverloads5.ts, 0, 0), Decl(callOverloads5.ts, 0, 19)) + +Foo("s"); +>Foo : Symbol(Foo, Decl(callOverloads5.ts, 0, 0), Decl(callOverloads5.ts, 0, 19)) + diff --git a/tests/baselines/reference/callOverloads5.types b/tests/baselines/reference/callOverloads5.types new file mode 100644 index 00000000000..1125fbe0ee1 --- /dev/null +++ b/tests/baselines/reference/callOverloads5.types @@ -0,0 +1,56 @@ +=== tests/cases/compiler/callOverloads5.ts === +function Foo():Foo; // error +>Foo : { (): any; (s: string): any; } +>Foo : No type information available! + +function Foo(s:string):Foo; // error +>Foo : { (): any; (s: string): any; } +>s : string +>Foo : No type information available! + +class Foo { // error +>Foo : Foo + + bar1(s:string); +>bar1 : { (s: string): any; (n: number): any; } +>s : string + + bar1(n:number); +>bar1 : { (s: string): any; (n: number): any; } +>n : number + + bar1(a:any) { /*WScript.Echo(a);*/ } +>bar1 : { (s: string): any; (n: number): any; } +>a : any + + constructor(x: any) { +>x : any + + // WScript.Echo("Constructor function has executed"); + } +} +//class Foo(s: String); + +var f1 = new Foo("hey"); +>f1 : any +>new Foo("hey") : any +>Foo : { (): any; (s: string): any; } +>"hey" : "hey" + + +f1.bar1("a"); +>f1.bar1("a") : any +>f1.bar1 : any +>f1 : any +>bar1 : any +>"a" : "a" + +Foo(); +>Foo() : any +>Foo : { (): any; (s: string): any; } + +Foo("s"); +>Foo("s") : any +>Foo : { (): any; (s: string): any; } +>"s" : "s" + diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance.symbols b/tests/baselines/reference/callSignatureAssignabilityInInheritance.symbols new file mode 100644 index 00000000000..00c48ef82e7 --- /dev/null +++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance.symbols @@ -0,0 +1,151 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance.ts === +module CallSignature { +>CallSignature : Symbol(CallSignature, Decl(callSignatureAssignabilityInInheritance.ts, 0, 0)) + + interface Base { // T +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance.ts, 0, 22)) + + // M's + (x: number): void; +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 3, 9)) + + (x: number, y: number): void; +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 4, 9)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance.ts, 4, 19)) + } + + // S's + interface I extends Base { +>I : Symbol(I, Decl(callSignatureAssignabilityInInheritance.ts, 5, 5)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance.ts, 0, 22)) + + // N's + (x: number): number; // ok because base returns void +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 10, 9)) + + (x: number, y: number): boolean; // ok because base returns void +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 11, 9)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance.ts, 11, 19)) + + (x: T): string; // ok because base returns void +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 12, 9)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 12, 12)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 12, 9)) + } + + interface Base2 { // T +>Base2 : Symbol(Base2, Decl(callSignatureAssignabilityInInheritance.ts, 13, 5)) + + // M's + (x: number): number; +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 17, 9)) + } + + // S's + interface I2 extends Base2 { +>I2 : Symbol(I2, Decl(callSignatureAssignabilityInInheritance.ts, 18, 5)) +>Base2 : Symbol(Base2, Decl(callSignatureAssignabilityInInheritance.ts, 13, 5)) + + // N's + (x: number): string; // error because base returns non-void; +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 23, 9)) + } + + // S's + interface I3 extends Base2 { +>I3 : Symbol(I3, Decl(callSignatureAssignabilityInInheritance.ts, 24, 5)) +>Base2 : Symbol(Base2, Decl(callSignatureAssignabilityInInheritance.ts, 13, 5)) + + // N's + (x: T): string; // ok, adds a new call signature +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 29, 9)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 29, 12)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 29, 9)) + } +} + +module MemberWithCallSignature { +>MemberWithCallSignature : Symbol(MemberWithCallSignature, Decl(callSignatureAssignabilityInInheritance.ts, 31, 1)) + + interface Base { // T +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance.ts, 33, 32)) + + // M's + a: (x: number) => void; +>a : Symbol(Base.a, Decl(callSignatureAssignabilityInInheritance.ts, 34, 20)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 36, 12)) + + a2: (x: number, y: number) => void; +>a2 : Symbol(Base.a2, Decl(callSignatureAssignabilityInInheritance.ts, 36, 31)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 37, 13)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance.ts, 37, 23)) + + a3: (x: T) => void; +>a3 : Symbol(Base.a3, Decl(callSignatureAssignabilityInInheritance.ts, 37, 43)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 38, 13)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 38, 16)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 38, 13)) + } + + // S's + interface I extends Base { +>I : Symbol(I, Decl(callSignatureAssignabilityInInheritance.ts, 39, 5)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance.ts, 33, 32)) + + // N's + a: (x: number) => number; // ok because base returns void +>a : Symbol(I.a, Decl(callSignatureAssignabilityInInheritance.ts, 42, 30)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 44, 12)) + + a2: (x: number, y: number) => boolean; // ok because base returns void +>a2 : Symbol(I.a2, Decl(callSignatureAssignabilityInInheritance.ts, 44, 33)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 45, 13)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance.ts, 45, 23)) + + a3: (x: T) => string; // ok because base returns void +>a3 : Symbol(I.a3, Decl(callSignatureAssignabilityInInheritance.ts, 45, 46)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 46, 13)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 46, 16)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 46, 13)) + } + + interface Base2 { // T +>Base2 : Symbol(Base2, Decl(callSignatureAssignabilityInInheritance.ts, 47, 5)) + + // M's + a: (x: number) => number; +>a : Symbol(Base2.a, Decl(callSignatureAssignabilityInInheritance.ts, 49, 21)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 51, 12)) + + a2: (x: T) => T; +>a2 : Symbol(Base2.a2, Decl(callSignatureAssignabilityInInheritance.ts, 51, 33)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 52, 13)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 52, 16)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 52, 13)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 52, 13)) + } + + // S's + interface I2 extends Base2 { +>I2 : Symbol(I2, Decl(callSignatureAssignabilityInInheritance.ts, 53, 5)) +>Base2 : Symbol(Base2, Decl(callSignatureAssignabilityInInheritance.ts, 47, 5)) + + // N's + a: (x: number) => string; // error because base returns non-void; +>a : Symbol(I2.a, Decl(callSignatureAssignabilityInInheritance.ts, 56, 32)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 58, 12)) + } + + // S's + interface I3 extends Base2 { +>I3 : Symbol(I3, Decl(callSignatureAssignabilityInInheritance.ts, 59, 5)) +>Base2 : Symbol(Base2, Decl(callSignatureAssignabilityInInheritance.ts, 47, 5)) + + // N's + a2: (x: T) => string; // error because base returns non-void; +>a2 : Symbol(I3.a2, Decl(callSignatureAssignabilityInInheritance.ts, 62, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 64, 13)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance.ts, 64, 16)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance.ts, 64, 13)) + } +} diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance.types b/tests/baselines/reference/callSignatureAssignabilityInInheritance.types new file mode 100644 index 00000000000..2463d04b91d --- /dev/null +++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance.types @@ -0,0 +1,151 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance.ts === +module CallSignature { +>CallSignature : any + + interface Base { // T +>Base : Base + + // M's + (x: number): void; +>x : number + + (x: number, y: number): void; +>x : number +>y : number + } + + // S's + interface I extends Base { +>I : I +>Base : Base + + // N's + (x: number): number; // ok because base returns void +>x : number + + (x: number, y: number): boolean; // ok because base returns void +>x : number +>y : number + + (x: T): string; // ok because base returns void +>T : T +>x : T +>T : T + } + + interface Base2 { // T +>Base2 : Base2 + + // M's + (x: number): number; +>x : number + } + + // S's + interface I2 extends Base2 { +>I2 : I2 +>Base2 : Base2 + + // N's + (x: number): string; // error because base returns non-void; +>x : number + } + + // S's + interface I3 extends Base2 { +>I3 : I3 +>Base2 : Base2 + + // N's + (x: T): string; // ok, adds a new call signature +>T : T +>x : T +>T : T + } +} + +module MemberWithCallSignature { +>MemberWithCallSignature : any + + interface Base { // T +>Base : Base + + // M's + a: (x: number) => void; +>a : (x: number) => void +>x : number + + a2: (x: number, y: number) => void; +>a2 : (x: number, y: number) => void +>x : number +>y : number + + a3: (x: T) => void; +>a3 : (x: T) => void +>T : T +>x : T +>T : T + } + + // S's + interface I extends Base { +>I : I +>Base : Base + + // N's + a: (x: number) => number; // ok because base returns void +>a : (x: number) => number +>x : number + + a2: (x: number, y: number) => boolean; // ok because base returns void +>a2 : (x: number, y: number) => boolean +>x : number +>y : number + + a3: (x: T) => string; // ok because base returns void +>a3 : (x: T) => string +>T : T +>x : T +>T : T + } + + interface Base2 { // T +>Base2 : Base2 + + // M's + a: (x: number) => number; +>a : (x: number) => number +>x : number + + a2: (x: T) => T; +>a2 : (x: T) => T +>T : T +>x : T +>T : T +>T : T + } + + // S's + interface I2 extends Base2 { +>I2 : I2 +>Base2 : Base2 + + // N's + a: (x: number) => string; // error because base returns non-void; +>a : (x: number) => string +>x : number + } + + // S's + interface I3 extends Base2 { +>I3 : I3 +>Base2 : Base2 + + // N's + a2: (x: T) => string; // error because base returns non-void; +>a2 : (x: T) => string +>T : T +>x : T +>T : T + } +} diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance3.symbols b/tests/baselines/reference/callSignatureAssignabilityInInheritance3.symbols new file mode 100644 index 00000000000..cbcc4076ffd --- /dev/null +++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance3.symbols @@ -0,0 +1,396 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance3.ts === +// checking subtype relations for function types as it relates to contextual signature instantiation +// error cases + +module Errors { +>Errors : Symbol(Errors, Decl(callSignatureAssignabilityInInheritance3.ts, 0, 0)) + + class Base { foo: string; } +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>foo : Symbol(Base.foo, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 16)) + + class Derived extends Base { bar: string; } +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>bar : Symbol(Derived.bar, Decl(callSignatureAssignabilityInInheritance3.ts, 5, 32)) + + class Derived2 extends Derived { baz: string; } +>Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance3.ts, 5, 47)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>baz : Symbol(Derived2.baz, Decl(callSignatureAssignabilityInInheritance3.ts, 6, 36)) + + class OtherDerived extends Base { bing: string; } +>OtherDerived : Symbol(OtherDerived, Decl(callSignatureAssignabilityInInheritance3.ts, 6, 51)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>bing : Symbol(OtherDerived.bing, Decl(callSignatureAssignabilityInInheritance3.ts, 7, 37)) + + module WithNonGenericSignaturesInBaseType { +>WithNonGenericSignaturesInBaseType : Symbol(WithNonGenericSignaturesInBaseType, Decl(callSignatureAssignabilityInInheritance3.ts, 7, 53)) + + // base type with non-generic call signatures + interface A { +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a2: (x: number) => string[]; +>a2 : Symbol(A.a2, Decl(callSignatureAssignabilityInInheritance3.ts, 11, 21)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 12, 17)) + + a7: (x: (arg: Base) => Derived) => (r: Base) => Derived2; +>a7 : Symbol(A.a7, Decl(callSignatureAssignabilityInInheritance3.ts, 12, 40)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 13, 17)) +>arg : Symbol(arg, Decl(callSignatureAssignabilityInInheritance3.ts, 13, 21)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>r : Symbol(r, Decl(callSignatureAssignabilityInInheritance3.ts, 13, 48)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance3.ts, 5, 47)) + + a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived; +>a8 : Symbol(A.a8, Decl(callSignatureAssignabilityInInheritance3.ts, 13, 69)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 14, 17)) +>arg : Symbol(arg, Decl(callSignatureAssignabilityInInheritance3.ts, 14, 21)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance3.ts, 14, 43)) +>arg2 : Symbol(arg2, Decl(callSignatureAssignabilityInInheritance3.ts, 14, 48)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>r : Symbol(r, Decl(callSignatureAssignabilityInInheritance3.ts, 14, 76)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) + + a10: (...x: Base[]) => Base; +>a10 : Symbol(A.a10, Decl(callSignatureAssignabilityInInheritance3.ts, 14, 96)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 15, 18)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) + + a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base; +>a11 : Symbol(A.a11, Decl(callSignatureAssignabilityInInheritance3.ts, 15, 40)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 16, 18)) +>foo : Symbol(foo, Decl(callSignatureAssignabilityInInheritance3.ts, 16, 22)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance3.ts, 16, 37)) +>foo : Symbol(foo, Decl(callSignatureAssignabilityInInheritance3.ts, 16, 42)) +>bar : Symbol(bar, Decl(callSignatureAssignabilityInInheritance3.ts, 16, 55)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) + + a12: (x: Array, y: Array) => Array; +>a12 : Symbol(A.a12, Decl(callSignatureAssignabilityInInheritance3.ts, 16, 79)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 17, 18)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance3.ts, 17, 33)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance3.ts, 5, 47)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) + + a14: { +>a14 : Symbol(A.a14, Decl(callSignatureAssignabilityInInheritance3.ts, 17, 72)) + + (x: number): number[]; +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 19, 17)) + + (x: string): string[]; +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 20, 17)) + + }; + a15: (x: { a: string; b: number }) => number; +>a15 : Symbol(A.a15, Decl(callSignatureAssignabilityInInheritance3.ts, 21, 14)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 22, 18)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 22, 22)) +>b : Symbol(b, Decl(callSignatureAssignabilityInInheritance3.ts, 22, 33)) + + a16: { +>a16 : Symbol(A.a16, Decl(callSignatureAssignabilityInInheritance3.ts, 22, 57)) + + // type of parameter is overload set which means we can't do inference based on this type + (x: { +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 25, 17)) + + (a: number): number; +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 26, 21)) + + (a?: number): number; +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 27, 21)) + + }): number[]; + (x: { +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 29, 17)) + + (a: boolean): boolean; +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 30, 21)) + + (a?: boolean): boolean; +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 31, 21)) + + }): boolean[]; + }; + a17: { +>a17 : Symbol(A.a17, Decl(callSignatureAssignabilityInInheritance3.ts, 33, 14)) + + (x: { +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 35, 17)) + + (a: T): T; +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 36, 21)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 36, 40)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 36, 21)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 36, 21)) + + (a: T): T; +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 37, 21)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 37, 37)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 37, 21)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 37, 21)) + + }): any[]; + (x: { +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 39, 17)) + + (a: T): T; +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 40, 21)) +>Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance3.ts, 5, 47)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 40, 41)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 40, 21)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 40, 21)) + + (a: T): T; +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 41, 21)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 41, 37)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 41, 21)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 41, 21)) + + }): any[]; + }; + } + + interface I extends A { +>I : Symbol(I, Decl(callSignatureAssignabilityInInheritance3.ts, 44, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a2: (x: T) => U[]; // error, contextual signature instantiation doesn't relate return types so U is {}, not a subtype of string[] +>a2 : Symbol(I.a2, Decl(callSignatureAssignabilityInInheritance3.ts, 46, 31)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 47, 17)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 47, 19)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 47, 23)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 47, 17)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 47, 19)) + } + + interface I2 extends A { +>I2 : Symbol(I2, Decl(callSignatureAssignabilityInInheritance3.ts, 48, 9)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 50, 21)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 50, 23)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a2: (x: T) => U[]; // error, no contextual signature instantiation since I2.a2 is not generic +>a2 : Symbol(I2.a2, Decl(callSignatureAssignabilityInInheritance3.ts, 50, 38)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 51, 17)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 50, 21)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 50, 23)) + } + + interface I3 extends A { +>I3 : Symbol(I3, Decl(callSignatureAssignabilityInInheritance3.ts, 52, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + // valid, no inferences for V so it defaults to Derived2 + a7: (x: (arg: T) => U) => (r: T) => V; +>a7 : Symbol(I3.a7, Decl(callSignatureAssignabilityInInheritance3.ts, 54, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 17)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 32)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>V : Symbol(V, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 51)) +>Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance3.ts, 5, 47)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 72)) +>arg : Symbol(arg, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 76)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 17)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 32)) +>r : Symbol(r, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 94)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 17)) +>V : Symbol(V, Decl(callSignatureAssignabilityInInheritance3.ts, 56, 51)) + } + + interface I4 extends A { +>I4 : Symbol(I4, Decl(callSignatureAssignabilityInInheritance3.ts, 57, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a8: (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; // error, type mismatch +>a8 : Symbol(I4.a8, Decl(callSignatureAssignabilityInInheritance3.ts, 59, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 17)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 32)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 52)) +>arg : Symbol(arg, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 56)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 17)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 32)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 69)) +>arg2 : Symbol(arg2, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 74)) +>foo : Symbol(foo, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 81)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 32)) +>r : Symbol(r, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 108)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 17)) +>U : Symbol(U, Decl(callSignatureAssignabilityInInheritance3.ts, 60, 32)) + } + + interface I4B extends A { +>I4B : Symbol(I4B, Decl(callSignatureAssignabilityInInheritance3.ts, 61, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a10: (...x: T[]) => T; // valid, parameter covariance works even after contextual signature instantiation +>a10 : Symbol(I4B.a10, Decl(callSignatureAssignabilityInInheritance3.ts, 63, 33)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 64, 18)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 64, 37)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 64, 18)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 64, 18)) + } + + interface I4C extends A { +>I4C : Symbol(I4C, Decl(callSignatureAssignabilityInInheritance3.ts, 65, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a11: (x: T, y: T) => T; // valid, even though x is a Base, parameter covariance works even after contextual signature instantiation +>a11 : Symbol(I4C.a11, Decl(callSignatureAssignabilityInInheritance3.ts, 67, 33)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 68, 18)) +>Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance3.ts, 4, 31)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 68, 37)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 68, 18)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance3.ts, 68, 42)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 68, 18)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 68, 18)) + } + + interface I4E extends A { +>I4E : Symbol(I4E, Decl(callSignatureAssignabilityInInheritance3.ts, 69, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a12: >(x: Array, y: Array) => T; // valid, no inferences for T, defaults to Array +>a12 : Symbol(I4E.a12, Decl(callSignatureAssignabilityInInheritance3.ts, 71, 33)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 72, 18)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance3.ts, 5, 47)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 72, 45)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>y : Symbol(y, Decl(callSignatureAssignabilityInInheritance3.ts, 72, 60)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 72, 18)) + } + + interface I6 extends A { +>I6 : Symbol(I6, Decl(callSignatureAssignabilityInInheritance3.ts, 73, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a15: (x: { a: T; b: T }) => T; // error, T is {} which isn't an acceptable return type +>a15 : Symbol(I6.a15, Decl(callSignatureAssignabilityInInheritance3.ts, 75, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 76, 18)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 76, 21)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 76, 25)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 76, 18)) +>b : Symbol(b, Decl(callSignatureAssignabilityInInheritance3.ts, 76, 31)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 76, 18)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 76, 18)) + } + + interface I7 extends A { +>I7 : Symbol(I7, Decl(callSignatureAssignabilityInInheritance3.ts, 77, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a15: (x: { a: T; b: T }) => number; // error, T defaults to Base, which is not compatible with number or string +>a15 : Symbol(I7.a15, Decl(callSignatureAssignabilityInInheritance3.ts, 79, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 80, 18)) +>Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance3.ts, 3, 15)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 80, 34)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 80, 38)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 80, 18)) +>b : Symbol(b, Decl(callSignatureAssignabilityInInheritance3.ts, 80, 44)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 80, 18)) + } + + interface I8 extends A { +>I8 : Symbol(I8, Decl(callSignatureAssignabilityInInheritance3.ts, 81, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + // ok, we relate each signature of a16 to b16, and within that, we make inferences from two different signatures in the respective A.a16 signature + a16: (x: (a: T) => T) => T[]; +>a16 : Symbol(I8.a16, Decl(callSignatureAssignabilityInInheritance3.ts, 83, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 85, 18)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 85, 21)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 85, 25)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 85, 18)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 85, 18)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 85, 18)) + } + + interface I9 extends A { +>I9 : Symbol(I9, Decl(callSignatureAssignabilityInInheritance3.ts, 86, 9)) +>A : Symbol(A, Decl(callSignatureAssignabilityInInheritance3.ts, 9, 47)) + + a17: (x: (a: T) => T) => any[]; // valid, target is more constrained than source, so it is safe in the traditional constraint-contravariant fashion +>a17 : Symbol(I9.a17, Decl(callSignatureAssignabilityInInheritance3.ts, 88, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 89, 18)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 89, 21)) +>a : Symbol(a, Decl(callSignatureAssignabilityInInheritance3.ts, 89, 25)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 89, 18)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 89, 18)) + } + } + + module WithGenericSignaturesInBaseType { +>WithGenericSignaturesInBaseType : Symbol(WithGenericSignaturesInBaseType, Decl(callSignatureAssignabilityInInheritance3.ts, 91, 5)) + + // base type has generic call signature + interface B { +>B : Symbol(B, Decl(callSignatureAssignabilityInInheritance3.ts, 93, 44)) + + a2: (x: T) => T[]; +>a2 : Symbol(B.a2, Decl(callSignatureAssignabilityInInheritance3.ts, 95, 21)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 96, 17)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 96, 20)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 96, 17)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 96, 17)) + } + + interface I6 extends B { +>I6 : Symbol(I6, Decl(callSignatureAssignabilityInInheritance3.ts, 97, 9)) +>B : Symbol(B, Decl(callSignatureAssignabilityInInheritance3.ts, 93, 44)) + + a2: (x: T) => string[]; // error +>a2 : Symbol(I6.a2, Decl(callSignatureAssignabilityInInheritance3.ts, 99, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 100, 17)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 100, 20)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 100, 17)) + } + + // base type has generic call signature + interface C { +>C : Symbol(C, Decl(callSignatureAssignabilityInInheritance3.ts, 101, 9)) + + a2: (x: T) => string[]; +>a2 : Symbol(C.a2, Decl(callSignatureAssignabilityInInheritance3.ts, 104, 21)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 105, 17)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 105, 20)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 105, 17)) + } + + interface I7 extends C { +>I7 : Symbol(I7, Decl(callSignatureAssignabilityInInheritance3.ts, 106, 9)) +>C : Symbol(C, Decl(callSignatureAssignabilityInInheritance3.ts, 101, 9)) + + a2: (x: T) => T[]; // error +>a2 : Symbol(I7.a2, Decl(callSignatureAssignabilityInInheritance3.ts, 108, 32)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 109, 17)) +>x : Symbol(x, Decl(callSignatureAssignabilityInInheritance3.ts, 109, 20)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 109, 17)) +>T : Symbol(T, Decl(callSignatureAssignabilityInInheritance3.ts, 109, 17)) + } + } +} diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance3.types b/tests/baselines/reference/callSignatureAssignabilityInInheritance3.types new file mode 100644 index 00000000000..6eb3ddaadea --- /dev/null +++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance3.types @@ -0,0 +1,396 @@ +=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/callSignatureAssignabilityInInheritance3.ts === +// checking subtype relations for function types as it relates to contextual signature instantiation +// error cases + +module Errors { +>Errors : typeof Errors + + class Base { foo: string; } +>Base : Base +>foo : string + + class Derived extends Base { bar: string; } +>Derived : Derived +>Base : Base +>bar : string + + class Derived2 extends Derived { baz: string; } +>Derived2 : Derived2 +>Derived : Derived +>baz : string + + class OtherDerived extends Base { bing: string; } +>OtherDerived : OtherDerived +>Base : Base +>bing : string + + module WithNonGenericSignaturesInBaseType { +>WithNonGenericSignaturesInBaseType : any + + // base type with non-generic call signatures + interface A { +>A : A + + a2: (x: number) => string[]; +>a2 : (x: number) => string[] +>x : number + + a7: (x: (arg: Base) => Derived) => (r: Base) => Derived2; +>a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived2 +>x : (arg: Base) => Derived +>arg : Base +>Base : Base +>Derived : Derived +>r : Base +>Base : Base +>Derived2 : Derived2 + + a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived; +>a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived +>x : (arg: Base) => Derived +>arg : Base +>Base : Base +>Derived : Derived +>y : (arg2: Base) => Derived +>arg2 : Base +>Base : Base +>Derived : Derived +>r : Base +>Base : Base +>Derived : Derived + + a10: (...x: Base[]) => Base; +>a10 : (...x: Base[]) => Base +>x : Base[] +>Base : Base +>Base : Base + + a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base; +>a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base +>x : { foo: string; } +>foo : string +>y : { foo: string; bar: string; } +>foo : string +>bar : string +>Base : Base + + a12: (x: Array, y: Array) => Array; +>a12 : (x: Base[], y: Derived2[]) => Derived[] +>x : Base[] +>Array : T[] +>Base : Base +>y : Derived2[] +>Array : T[] +>Derived2 : Derived2 +>Array : T[] +>Derived : Derived + + a14: { +>a14 : { (x: number): number[]; (x: string): string[]; } + + (x: number): number[]; +>x : number + + (x: string): string[]; +>x : string + + }; + a15: (x: { a: string; b: number }) => number; +>a15 : (x: { a: string; b: number; }) => number +>x : { a: string; b: number; } +>a : string +>b : number + + a16: { +>a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; } + + // type of parameter is overload set which means we can't do inference based on this type + (x: { +>x : { (a: number): number; (a?: number): number; } + + (a: number): number; +>a : number + + (a?: number): number; +>a : number + + }): number[]; + (x: { +>x : { (a: boolean): boolean; (a?: boolean): boolean; } + + (a: boolean): boolean; +>a : boolean + + (a?: boolean): boolean; +>a : boolean + + }): boolean[]; + }; + a17: { +>a17 : { (x: { (a: T): T; (a: T): T; }): any[]; (x: { (a: T): T; (a: T): T; }): any[]; } + + (x: { +>x : { (a: T): T; (a: T): T; } + + (a: T): T; +>T : T +>Derived : Derived +>a : T +>T : T +>T : T + + (a: T): T; +>T : T +>Base : Base +>a : T +>T : T +>T : T + + }): any[]; + (x: { +>x : { (a: T): T; (a: T): T; } + + (a: T): T; +>T : T +>Derived2 : Derived2 +>a : T +>T : T +>T : T + + (a: T): T; +>T : T +>Base : Base +>a : T +>T : T +>T : T + + }): any[]; + }; + } + + interface I extends A { +>I : I +>A : A + + a2: (x: T) => U[]; // error, contextual signature instantiation doesn't relate return types so U is {}, not a subtype of string[] +>a2 : (x: T) => U[] +>T : T +>U : U +>x : T +>T : T +>U : U + } + + interface I2 extends A { +>I2 : I2 +>T : T +>U : U +>A : A + + a2: (x: T) => U[]; // error, no contextual signature instantiation since I2.a2 is not generic +>a2 : (x: T) => U[] +>x : T +>T : T +>U : U + } + + interface I3 extends A { +>I3 : I3 +>A : A + + // valid, no inferences for V so it defaults to Derived2 + a7: (x: (arg: T) => U) => (r: T) => V; +>a7 : (x: (arg: T) => U) => (r: T) => V +>T : T +>Base : Base +>U : U +>Derived : Derived +>V : V +>Derived2 : Derived2 +>x : (arg: T) => U +>arg : T +>T : T +>U : U +>r : T +>T : T +>V : V + } + + interface I4 extends A { +>I4 : I4 +>A : A + + a8: (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; // error, type mismatch +>a8 : (x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U +>T : T +>Base : Base +>U : U +>Derived : Derived +>x : (arg: T) => U +>arg : T +>T : T +>U : U +>y : (arg2: { foo: number; }) => U +>arg2 : { foo: number; } +>foo : number +>U : U +>r : T +>T : T +>U : U + } + + interface I4B extends A { +>I4B : I4B +>A : A + + a10: (...x: T[]) => T; // valid, parameter covariance works even after contextual signature instantiation +>a10 : (...x: T[]) => T +>T : T +>Derived : Derived +>x : T[] +>T : T +>T : T + } + + interface I4C extends A { +>I4C : I4C +>A : A + + a11: (x: T, y: T) => T; // valid, even though x is a Base, parameter covariance works even after contextual signature instantiation +>a11 : (x: T, y: T) => T +>T : T +>Derived : Derived +>x : T +>T : T +>y : T +>T : T +>T : T + } + + interface I4E extends A { +>I4E : I4E +>A : A + + a12: >(x: Array, y: Array) => T; // valid, no inferences for T, defaults to Array +>a12 : (x: Base[], y: Base[]) => T +>T : T +>Array : T[] +>Derived2 : Derived2 +>x : Base[] +>Array : T[] +>Base : Base +>y : Base[] +>Array : T[] +>Base : Base +>T : T + } + + interface I6 extends A { +>I6 : I6 +>A : A + + a15: (x: { a: T; b: T }) => T; // error, T is {} which isn't an acceptable return type +>a15 : (x: { a: T; b: T; }) => T +>T : T +>x : { a: T; b: T; } +>a : T +>T : T +>b : T +>T : T +>T : T + } + + interface I7 extends A { +>I7 : I7 +>A : A + + a15: (x: { a: T; b: T }) => number; // error, T defaults to Base, which is not compatible with number or string +>a15 : (x: { a: T; b: T; }) => number +>T : T +>Base : Base +>x : { a: T; b: T; } +>a : T +>T : T +>b : T +>T : T + } + + interface I8 extends A { +>I8 : I8 +>A : A + + // ok, we relate each signature of a16 to b16, and within that, we make inferences from two different signatures in the respective A.a16 signature + a16: (x: (a: T) => T) => T[]; +>a16 : (x: (a: T) => T) => T[] +>T : T +>x : (a: T) => T +>a : T +>T : T +>T : T +>T : T + } + + interface I9 extends A { +>I9 : I9 +>A : A + + a17: (x: (a: T) => T) => any[]; // valid, target is more constrained than source, so it is safe in the traditional constraint-contravariant fashion +>a17 : (x: (a: T) => T) => any[] +>T : T +>x : (a: T) => T +>a : T +>T : T +>T : T + } + } + + module WithGenericSignaturesInBaseType { +>WithGenericSignaturesInBaseType : any + + // base type has generic call signature + interface B { +>B : B + + a2: (x: T) => T[]; +>a2 : (x: T) => T[] +>T : T +>x : T +>T : T +>T : T + } + + interface I6 extends B { +>I6 : I6 +>B : B + + a2: (x: T) => string[]; // error +>a2 : (x: T) => string[] +>T : T +>x : T +>T : T + } + + // base type has generic call signature + interface C { +>C : C + + a2: (x: T) => string[]; +>a2 : (x: T) => string[] +>T : T +>x : T +>T : T + } + + interface I7 extends C { +>I7 : I7 +>C : C + + a2: (x: T) => T[]; // error +>a2 : (x: T) => T[] +>T : T +>x : T +>T : T +>T : T + } + } +} diff --git a/tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.symbols b/tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.symbols new file mode 100644 index 00000000000..1d562856d07 --- /dev/null +++ b/tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.symbols @@ -0,0 +1,164 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithOptionalParameterAndInitializer.ts === +// Optional parameters cannot also have initializer expressions, these are all errors + +function foo(x?: number = 1) { } +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 0, 0)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 2, 13)) + +var f = function foo(x?: number = 1) { } +>f : Symbol(f, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 3, 3)) +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 3, 7)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 3, 21)) + +var f2 = (x: number, y? = 1) => { } +>f2 : Symbol(f2, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 4, 3)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 4, 10)) +>y : Symbol(y, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 4, 20)) + +foo(1); +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 0, 0)) + +foo(); +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 0, 0)) + +f(1); +>f : Symbol(f, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 3, 3)) + +f(); +>f : Symbol(f, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 3, 3)) + +f2(1); +>f2 : Symbol(f2, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 4, 3)) + +f2(1, 2); +>f2 : Symbol(f2, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 4, 3)) + +class C { +>C : Symbol(C, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 11, 9)) + + foo(x?: number = 1) { } +>foo : Symbol(C.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 13, 9)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 14, 8)) +} + +var c: C; +>c : Symbol(c, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 17, 3)) +>C : Symbol(C, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 11, 9)) + +c.foo(); +>c.foo : Symbol(C.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 13, 9)) +>c : Symbol(c, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 17, 3)) +>foo : Symbol(C.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 13, 9)) + +c.foo(1); +>c.foo : Symbol(C.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 13, 9)) +>c : Symbol(c, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 17, 3)) +>foo : Symbol(C.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 13, 9)) + +interface I { +>I : Symbol(I, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 19, 9)) + + (x? = 1); +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 22, 5)) + + foo(x: number, y?: number = 1); +>foo : Symbol(I.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 22, 13)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 23, 8)) +>y : Symbol(y, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 23, 18)) +} + +var i: I; +>i : Symbol(i, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 26, 3)) +>I : Symbol(I, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 19, 9)) + +i(); +>i : Symbol(i, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 26, 3)) + +i(1); +>i : Symbol(i, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 26, 3)) + +i.foo(1); +>i.foo : Symbol(I.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 22, 13)) +>i : Symbol(i, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 26, 3)) +>foo : Symbol(I.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 22, 13)) + +i.foo(1, 2); +>i.foo : Symbol(I.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 22, 13)) +>i : Symbol(i, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 26, 3)) +>foo : Symbol(I.foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 22, 13)) + +var a: { +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 32, 3)) + + (x?: number = 1); +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 33, 5)) + + foo(x? = 1); +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 33, 21)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 34, 8)) +} + +a(); +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 32, 3)) + +a(1); +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 32, 3)) + +a.foo(); +>a.foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 33, 21)) +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 32, 3)) +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 33, 21)) + +a.foo(1); +>a.foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 33, 21)) +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 32, 3)) +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 33, 21)) + +var b = { +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 3)) + + foo(x?: number = 1) { }, +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 9)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 43, 8)) + + a: function foo(x: number, y?: number = '') { }, +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 43, 28)) +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 6)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 20)) +>y : Symbol(y, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 30)) + + b: (x?: any = '') => { } +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 52)) +>x : Symbol(x, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 45, 8)) +} + +b.foo(); +>b.foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 9)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 3)) +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 9)) + +b.foo(1); +>b.foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 9)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 3)) +>foo : Symbol(foo, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 9)) + +b.a(1); +>b.a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 43, 28)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 3)) +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 43, 28)) + +b.a(1, 2); +>b.a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 43, 28)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 3)) +>a : Symbol(a, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 43, 28)) + +b.b(); +>b.b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 52)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 3)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 52)) + +b.b(1); +>b.b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 52)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 42, 3)) +>b : Symbol(b, Decl(callSignatureWithOptionalParameterAndInitializer.ts, 44, 52)) + diff --git a/tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.types b/tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.types new file mode 100644 index 00000000000..fa3ddead9e5 --- /dev/null +++ b/tests/baselines/reference/callSignatureWithOptionalParameterAndInitializer.types @@ -0,0 +1,219 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithOptionalParameterAndInitializer.ts === +// Optional parameters cannot also have initializer expressions, these are all errors + +function foo(x?: number = 1) { } +>foo : (x?: number) => void +>x : number +>1 : 1 + +var f = function foo(x?: number = 1) { } +>f : (x?: number) => void +>function foo(x?: number = 1) { } : (x?: number) => void +>foo : (x?: number) => void +>x : number +>1 : 1 + +var f2 = (x: number, y? = 1) => { } +>f2 : (x: number, y?: number) => void +>(x: number, y? = 1) => { } : (x: number, y?: number) => void +>x : number +>y : number +>1 : 1 + +foo(1); +>foo(1) : void +>foo : (x?: number) => void +>1 : 1 + +foo(); +>foo() : void +>foo : (x?: number) => void + +f(1); +>f(1) : void +>f : (x?: number) => void +>1 : 1 + +f(); +>f() : void +>f : (x?: number) => void + +f2(1); +>f2(1) : void +>f2 : (x: number, y?: number) => void +>1 : 1 + +f2(1, 2); +>f2(1, 2) : void +>f2 : (x: number, y?: number) => void +>1 : 1 +>2 : 2 + +class C { +>C : C + + foo(x?: number = 1) { } +>foo : (x?: number) => void +>x : number +>1 : 1 +} + +var c: C; +>c : C +>C : C + +c.foo(); +>c.foo() : void +>c.foo : (x?: number) => void +>c : C +>foo : (x?: number) => void + +c.foo(1); +>c.foo(1) : void +>c.foo : (x?: number) => void +>c : C +>foo : (x?: number) => void +>1 : 1 + +interface I { +>I : I + + (x? = 1); +>x : number +>1 : 1 + + foo(x: number, y?: number = 1); +>foo : (x: number, y?: number) => any +>x : number +>y : number +>1 : 1 +} + +var i: I; +>i : I +>I : I + +i(); +>i() : any +>i : I + +i(1); +>i(1) : any +>i : I +>1 : 1 + +i.foo(1); +>i.foo(1) : any +>i.foo : (x: number, y?: number) => any +>i : I +>foo : (x: number, y?: number) => any +>1 : 1 + +i.foo(1, 2); +>i.foo(1, 2) : any +>i.foo : (x: number, y?: number) => any +>i : I +>foo : (x: number, y?: number) => any +>1 : 1 +>2 : 2 + +var a: { +>a : { (x?: number): any; foo(x?: number): any; } + + (x?: number = 1); +>x : number +>1 : 1 + + foo(x? = 1); +>foo : (x?: number) => any +>x : number +>1 : 1 +} + +a(); +>a() : any +>a : { (x?: number): any; foo(x?: number): any; } + +a(1); +>a(1) : any +>a : { (x?: number): any; foo(x?: number): any; } +>1 : 1 + +a.foo(); +>a.foo() : any +>a.foo : (x?: number) => any +>a : { (x?: number): any; foo(x?: number): any; } +>foo : (x?: number) => any + +a.foo(1); +>a.foo(1) : any +>a.foo : (x?: number) => any +>a : { (x?: number): any; foo(x?: number): any; } +>foo : (x?: number) => any +>1 : 1 + +var b = { +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } +>{ foo(x?: number = 1) { }, a: function foo(x: number, y?: number = '') { }, b: (x?: any = '') => { }} : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } + + foo(x?: number = 1) { }, +>foo : (x?: number) => void +>x : number +>1 : 1 + + a: function foo(x: number, y?: number = '') { }, +>a : (x: number, y?: number) => void +>function foo(x: number, y?: number = '') { } : (x: number, y?: number) => void +>foo : (x: number, y?: number) => void +>x : number +>y : number +>'' : "" + + b: (x?: any = '') => { } +>b : (x?: any) => void +>(x?: any = '') => { } : (x?: any) => void +>x : any +>'' : "" +} + +b.foo(); +>b.foo() : void +>b.foo : (x?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } +>foo : (x?: number) => void + +b.foo(1); +>b.foo(1) : void +>b.foo : (x?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } +>foo : (x?: number) => void +>1 : 1 + +b.a(1); +>b.a(1) : void +>b.a : (x: number, y?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } +>a : (x: number, y?: number) => void +>1 : 1 + +b.a(1, 2); +>b.a(1, 2) : void +>b.a : (x: number, y?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } +>a : (x: number, y?: number) => void +>1 : 1 +>2 : 2 + +b.b(); +>b.b() : void +>b.b : (x?: any) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } +>b : (x?: any) => void + +b.b(1); +>b.b(1) : void +>b.b : (x?: any) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: any) => void; } +>b : (x?: any) => void +>1 : 1 + diff --git a/tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.symbols b/tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.symbols new file mode 100644 index 00000000000..1d0d3c3b6bd --- /dev/null +++ b/tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/callSignaturesShouldBeResolvedBeforeSpecialization.ts === +interface I1 { +>I1 : Symbol(I1, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 0, 0)) +>T : Symbol(T, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 0, 13)) + + (value: T): void; +>value : Symbol(value, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 1, 5)) +>T : Symbol(T, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 0, 13)) + + field1: I1; +>field1 : Symbol(I1.field1, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 1, 21)) +>I1 : Symbol(I1, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 0, 0)) +} + +function foo() { +>foo : Symbol(foo, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 3, 1)) + + var test: I1; +>test : Symbol(test, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 6, 7)) +>I1 : Symbol(I1, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 0, 0)) + + test("expects boolean instead of string"); // should not error - "test" should not expect a boolean +>test : Symbol(test, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 6, 7)) + + test(true); // should error - string expected +>test : Symbol(test, Decl(callSignaturesShouldBeResolvedBeforeSpecialization.ts, 6, 7)) +} diff --git a/tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.types b/tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.types new file mode 100644 index 00000000000..7c20d48a235 --- /dev/null +++ b/tests/baselines/reference/callSignaturesShouldBeResolvedBeforeSpecialization.types @@ -0,0 +1,31 @@ +=== tests/cases/compiler/callSignaturesShouldBeResolvedBeforeSpecialization.ts === +interface I1 { +>I1 : I1 +>T : T + + (value: T): void; +>value : T +>T : T + + field1: I1; +>field1 : I1 +>I1 : I1 +} + +function foo() { +>foo : () => void + + var test: I1; +>test : I1 +>I1 : I1 + + test("expects boolean instead of string"); // should not error - "test" should not expect a boolean +>test("expects boolean instead of string") : void +>test : I1 +>"expects boolean instead of string" : "expects boolean instead of string" + + test(true); // should error - string expected +>test(true) : any +>test : I1 +>true : true +} diff --git a/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.symbols b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.symbols new file mode 100644 index 00000000000..7d72abdcb49 --- /dev/null +++ b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.symbols @@ -0,0 +1,36 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesThatDifferOnlyByReturnType2.ts === +// Normally it is an error to have multiple overloads which differ only by return type in a single type declaration. +// Here the multiple overloads come from multiple bases. + +interface I { +>I : Symbol(I, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 0, 0)) +>T : Symbol(T, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 3, 12)) + + foo(x: number): T; +>foo : Symbol(I.foo, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 3, 16)) +>x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 4, 8)) +>T : Symbol(T, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 3, 12)) +} + +interface A extends I, I { } +>A : Symbol(A, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 5, 1)) +>I : Symbol(I, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 0, 0)) +>I : Symbol(I, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 0, 0)) + +var x: A; +>x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 9, 3)) +>A : Symbol(A, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 5, 1)) + +// BUG 822524 +var r = x.foo(1); // no error +>r : Symbol(r, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 11, 3)) +>x.foo : Symbol(I.foo, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 3, 16)) +>x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 9, 3)) +>foo : Symbol(I.foo, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 3, 16)) + +var r2 = x.foo(''); // error +>r2 : Symbol(r2, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 12, 3)) +>x.foo : Symbol(I.foo, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 3, 16)) +>x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 9, 3)) +>foo : Symbol(I.foo, Decl(callSignaturesThatDifferOnlyByReturnType2.ts, 3, 16)) + diff --git a/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.types b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.types new file mode 100644 index 00000000000..18b23b2eb93 --- /dev/null +++ b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType2.types @@ -0,0 +1,40 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesThatDifferOnlyByReturnType2.ts === +// Normally it is an error to have multiple overloads which differ only by return type in a single type declaration. +// Here the multiple overloads come from multiple bases. + +interface I { +>I : I +>T : T + + foo(x: number): T; +>foo : (x: number) => T +>x : number +>T : T +} + +interface A extends I, I { } +>A : A +>I : I +>I : I + +var x: A; +>x : A +>A : A + +// BUG 822524 +var r = x.foo(1); // no error +>r : number +>x.foo(1) : number +>x.foo : (x: number) => number +>x : A +>foo : (x: number) => number +>1 : 1 + +var r2 = x.foo(''); // error +>r2 : number +>x.foo('') : number +>x.foo : (x: number) => number +>x : A +>foo : (x: number) => number +>'' : "" + diff --git a/tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.symbols b/tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.symbols new file mode 100644 index 00000000000..66f11181314 --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.symbols @@ -0,0 +1,150 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithAccessibilityModifiersOnParameters.ts === +// Call signature parameters do not allow accessibility modifiers + +function foo(public x, private y) { } +>foo : Symbol(foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 0, 0)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 2, 13)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 2, 22)) + +var f = function foo(public x, private y) { } +>f : Symbol(f, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 3, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 3, 7)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 3, 21)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 3, 30)) + +var f2 = function (public x, private y) { } +>f2 : Symbol(f2, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 4, 3)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 4, 19)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 4, 28)) + +var f3 = (x, private y) => { } +>f3 : Symbol(f3, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 5, 3)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 5, 10)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 5, 12)) + +var f4 = (public x: T, y: T) => { } +>f4 : Symbol(f4, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 6, 3)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 6, 10)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 6, 13)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 6, 10)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 6, 25)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 6, 10)) + +function foo2(private x: string, public y: number) { } +>foo2 : Symbol(foo2, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 6, 38)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 8, 14)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 8, 32)) + +var f5 = function foo(private x: string, public y: number) { } +>f5 : Symbol(f5, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 9, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 9, 8)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 9, 22)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 9, 40)) + +var f6 = function (private x: string, public y: number) { } +>f6 : Symbol(f6, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 10, 3)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 10, 19)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 10, 37)) + +var f7 = (private x: string, public y: number) => { } +>f7 : Symbol(f7, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 11, 3)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 11, 10)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 11, 28)) + +var f8 = (private x: T, public y: T) => { } +>f8 : Symbol(f8, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 12, 3)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 12, 10)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 12, 13)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 12, 10)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 12, 26)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 12, 10)) + +class C { +>C : Symbol(C, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 12, 46)) + + foo(public x, private y) { } +>foo : Symbol(C.foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 14, 9)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 15, 8)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 15, 17)) + + foo2(public x: number, private y: string) { } +>foo2 : Symbol(C.foo2, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 15, 32)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 16, 9)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 16, 26)) + + foo3(public x: T, private y: T) { } +>foo3 : Symbol(C.foo3, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 16, 49)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 17, 9)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 17, 12)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 17, 9)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 17, 24)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 17, 9)) +} + +interface I { +>I : Symbol(I, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 18, 1)) + + (private x, public y); +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 21, 5)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 21, 15)) + + (private x: string, public y: number); +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 22, 5)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 22, 23)) + + foo(private x, public y); +>foo : Symbol(I.foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 22, 42), Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 23, 29)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 23, 8)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 23, 18)) + + foo(public x: number, y: string); +>foo : Symbol(I.foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 22, 42), Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 23, 29)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 24, 8)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 24, 25)) + + foo3(x: T, private y: T); +>foo3 : Symbol(I.foo3, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 24, 37)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 25, 9)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 25, 12)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 25, 9)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 25, 17)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 25, 9)) +} + +var a: { +>a : Symbol(a, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 28, 3)) + + foo(public x, private y); +>foo : Symbol(foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 28, 8)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 29, 8)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 29, 17)) + + foo2(private x: number, public y: string); +>foo2 : Symbol(foo2, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 29, 29)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 30, 9)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 30, 27)) + +}; + +var b = { +>b : Symbol(b, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 33, 3)) + + foo(public x, y) { }, +>foo : Symbol(foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 33, 9)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 34, 8)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 34, 17)) + + a: function foo(x: number, private y: string) { }, +>a : Symbol(a, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 34, 25)) +>foo : Symbol(foo, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 35, 6)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 35, 20)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 35, 30)) + + b: (public x: T, private y: T) => { } +>b : Symbol(b, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 35, 54)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 36, 8)) +>x : Symbol(x, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 36, 11)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 36, 8)) +>y : Symbol(y, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 36, 23)) +>T : Symbol(T, Decl(callSignaturesWithAccessibilityModifiersOnParameters.ts, 36, 8)) +} diff --git a/tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.types b/tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.types new file mode 100644 index 00000000000..af074b5faa0 --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithAccessibilityModifiersOnParameters.types @@ -0,0 +1,161 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithAccessibilityModifiersOnParameters.ts === +// Call signature parameters do not allow accessibility modifiers + +function foo(public x, private y) { } +>foo : (public x: any, private y: any) => void +>x : any +>y : any + +var f = function foo(public x, private y) { } +>f : (public x: any, private y: any) => void +>function foo(public x, private y) { } : (public x: any, private y: any) => void +>foo : (public x: any, private y: any) => void +>x : any +>y : any + +var f2 = function (public x, private y) { } +>f2 : (public x: any, private y: any) => void +>function (public x, private y) { } : (public x: any, private y: any) => void +>x : any +>y : any + +var f3 = (x, private y) => { } +>f3 : (x: any, private y: any) => void +>(x, private y) => { } : (x: any, private y: any) => void +>x : any +>y : any + +var f4 = (public x: T, y: T) => { } +>f4 : (public x: T, y: T) => void +>(public x: T, y: T) => { } : (public x: T, y: T) => void +>T : T +>x : T +>T : T +>y : T +>T : T + +function foo2(private x: string, public y: number) { } +>foo2 : (private x: string, public y: number) => void +>x : string +>y : number + +var f5 = function foo(private x: string, public y: number) { } +>f5 : (private x: string, public y: number) => void +>function foo(private x: string, public y: number) { } : (private x: string, public y: number) => void +>foo : (private x: string, public y: number) => void +>x : string +>y : number + +var f6 = function (private x: string, public y: number) { } +>f6 : (private x: string, public y: number) => void +>function (private x: string, public y: number) { } : (private x: string, public y: number) => void +>x : string +>y : number + +var f7 = (private x: string, public y: number) => { } +>f7 : (private x: string, public y: number) => void +>(private x: string, public y: number) => { } : (private x: string, public y: number) => void +>x : string +>y : number + +var f8 = (private x: T, public y: T) => { } +>f8 : (private x: T, public y: T) => void +>(private x: T, public y: T) => { } : (private x: T, public y: T) => void +>T : T +>x : T +>T : T +>y : T +>T : T + +class C { +>C : C + + foo(public x, private y) { } +>foo : (public x: any, private y: any) => void +>x : any +>y : any + + foo2(public x: number, private y: string) { } +>foo2 : (public x: number, private y: string) => void +>x : number +>y : string + + foo3(public x: T, private y: T) { } +>foo3 : (public x: T, private y: T) => void +>T : T +>x : T +>T : T +>y : T +>T : T +} + +interface I { +>I : I + + (private x, public y); +>x : any +>y : any + + (private x: string, public y: number); +>x : string +>y : number + + foo(private x, public y); +>foo : { (private x: any, public y: any): any; (public x: number, y: string): any; } +>x : any +>y : any + + foo(public x: number, y: string); +>foo : { (private x: any, public y: any): any; (public x: number, y: string): any; } +>x : number +>y : string + + foo3(x: T, private y: T); +>foo3 : (x: T, private y: T) => any +>T : T +>x : T +>T : T +>y : T +>T : T +} + +var a: { +>a : { foo(public x: any, private y: any): any; foo2(private x: number, public y: string): any; } + + foo(public x, private y); +>foo : (public x: any, private y: any) => any +>x : any +>y : any + + foo2(private x: number, public y: string); +>foo2 : (private x: number, public y: string) => any +>x : number +>y : string + +}; + +var b = { +>b : { foo(public x: any, y: any): void; a: (x: number, private y: string) => void; b: (public x: T, private y: T) => void; } +>{ foo(public x, y) { }, a: function foo(x: number, private y: string) { }, b: (public x: T, private y: T) => { }} : { foo(public x: any, y: any): void; a: (x: number, private y: string) => void; b: (public x: T, private y: T) => void; } + + foo(public x, y) { }, +>foo : (public x: any, y: any) => void +>x : any +>y : any + + a: function foo(x: number, private y: string) { }, +>a : (x: number, private y: string) => void +>function foo(x: number, private y: string) { } : (x: number, private y: string) => void +>foo : (x: number, private y: string) => void +>x : number +>y : string + + b: (public x: T, private y: T) => { } +>b : (public x: T, private y: T) => void +>(public x: T, private y: T) => { } : (public x: T, private y: T) => void +>T : T +>x : T +>T : T +>y : T +>T : T +} diff --git a/tests/baselines/reference/callSignaturesWithDuplicateParameters.symbols b/tests/baselines/reference/callSignaturesWithDuplicateParameters.symbols new file mode 100644 index 00000000000..9adebf1a419 --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithDuplicateParameters.symbols @@ -0,0 +1,150 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithDuplicateParameters.ts === +// Duplicate parameter names are always an error + +function foo(x, x) { } +>foo : Symbol(foo, Decl(callSignaturesWithDuplicateParameters.ts, 0, 0)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 2, 13)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 2, 15)) + +var f = function foo(x, x) { } +>f : Symbol(f, Decl(callSignaturesWithDuplicateParameters.ts, 3, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithDuplicateParameters.ts, 3, 7)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 3, 21)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 3, 23)) + +var f2 = function (x, x) { } +>f2 : Symbol(f2, Decl(callSignaturesWithDuplicateParameters.ts, 4, 3)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 4, 19)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 4, 21)) + +var f3 = (x, x) => { } +>f3 : Symbol(f3, Decl(callSignaturesWithDuplicateParameters.ts, 5, 3)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 5, 10)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 5, 12)) + +var f4 = (x: T, x: T) => { } +>f4 : Symbol(f4, Decl(callSignaturesWithDuplicateParameters.ts, 6, 3)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 6, 10)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 6, 13)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 6, 10)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 6, 18)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 6, 10)) + +function foo2(x: string, x: number) { } +>foo2 : Symbol(foo2, Decl(callSignaturesWithDuplicateParameters.ts, 6, 31)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 8, 14)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 8, 24)) + +var f5 = function foo(x: string, x: number) { } +>f5 : Symbol(f5, Decl(callSignaturesWithDuplicateParameters.ts, 9, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithDuplicateParameters.ts, 9, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 9, 22)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 9, 32)) + +var f6 = function (x: string, x: number) { } +>f6 : Symbol(f6, Decl(callSignaturesWithDuplicateParameters.ts, 10, 3)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 10, 19)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 10, 29)) + +var f7 = (x: string, x: number) => { } +>f7 : Symbol(f7, Decl(callSignaturesWithDuplicateParameters.ts, 11, 3)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 11, 10)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 11, 20)) + +var f8 = (x: T, y: T) => { } +>f8 : Symbol(f8, Decl(callSignaturesWithDuplicateParameters.ts, 12, 3)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 12, 10)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 12, 13)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 12, 10)) +>y : Symbol(y, Decl(callSignaturesWithDuplicateParameters.ts, 12, 18)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 12, 10)) + +class C { +>C : Symbol(C, Decl(callSignaturesWithDuplicateParameters.ts, 12, 31)) + + foo(x, x) { } +>foo : Symbol(C.foo, Decl(callSignaturesWithDuplicateParameters.ts, 14, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 15, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 15, 10)) + + foo2(x: number, x: string) { } +>foo2 : Symbol(C.foo2, Decl(callSignaturesWithDuplicateParameters.ts, 15, 17)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 16, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 16, 19)) + + foo3(x: T, x: T) { } +>foo3 : Symbol(C.foo3, Decl(callSignaturesWithDuplicateParameters.ts, 16, 34)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 17, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 17, 12)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 17, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 17, 17)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 17, 9)) +} + +interface I { +>I : Symbol(I, Decl(callSignaturesWithDuplicateParameters.ts, 18, 1)) + + (x, x); +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 21, 5)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 21, 7)) + + (x: string, x: number); +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 22, 5)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 22, 15)) + + foo(x, x); +>foo : Symbol(I.foo, Decl(callSignaturesWithDuplicateParameters.ts, 22, 27), Decl(callSignaturesWithDuplicateParameters.ts, 23, 14)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 23, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 23, 10)) + + foo(x: number, x: string); +>foo : Symbol(I.foo, Decl(callSignaturesWithDuplicateParameters.ts, 22, 27), Decl(callSignaturesWithDuplicateParameters.ts, 23, 14)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 24, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 24, 18)) + + foo3(x: T, x: T); +>foo3 : Symbol(I.foo3, Decl(callSignaturesWithDuplicateParameters.ts, 24, 30)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 25, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 25, 12)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 25, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 25, 17)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 25, 9)) +} + +var a: { +>a : Symbol(a, Decl(callSignaturesWithDuplicateParameters.ts, 28, 3)) + + foo(x, x); +>foo : Symbol(foo, Decl(callSignaturesWithDuplicateParameters.ts, 28, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 29, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 29, 10)) + + foo2(x: number, x: string); +>foo2 : Symbol(foo2, Decl(callSignaturesWithDuplicateParameters.ts, 29, 14)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 30, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 30, 19)) + +}; + +var b = { +>b : Symbol(b, Decl(callSignaturesWithDuplicateParameters.ts, 33, 3)) + + foo(x, x) { }, +>foo : Symbol(foo, Decl(callSignaturesWithDuplicateParameters.ts, 33, 9)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 34, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 34, 10)) + + a: function foo(x: number, x: string) { }, +>a : Symbol(a, Decl(callSignaturesWithDuplicateParameters.ts, 34, 18)) +>foo : Symbol(foo, Decl(callSignaturesWithDuplicateParameters.ts, 35, 6)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 35, 20)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 35, 30)) + + b: (x: T, x: T) => { } +>b : Symbol(b, Decl(callSignaturesWithDuplicateParameters.ts, 35, 46)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 36, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 36, 11)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 36, 8)) +>x : Symbol(x, Decl(callSignaturesWithDuplicateParameters.ts, 36, 16)) +>T : Symbol(T, Decl(callSignaturesWithDuplicateParameters.ts, 36, 8)) +} diff --git a/tests/baselines/reference/callSignaturesWithDuplicateParameters.types b/tests/baselines/reference/callSignaturesWithDuplicateParameters.types new file mode 100644 index 00000000000..926f1ca3313 --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithDuplicateParameters.types @@ -0,0 +1,161 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithDuplicateParameters.ts === +// Duplicate parameter names are always an error + +function foo(x, x) { } +>foo : (x: any, x: any) => void +>x : any +>x : any + +var f = function foo(x, x) { } +>f : (x: any, x: any) => void +>function foo(x, x) { } : (x: any, x: any) => void +>foo : (x: any, x: any) => void +>x : any +>x : any + +var f2 = function (x, x) { } +>f2 : (x: any, x: any) => void +>function (x, x) { } : (x: any, x: any) => void +>x : any +>x : any + +var f3 = (x, x) => { } +>f3 : (x: any, x: any) => void +>(x, x) => { } : (x: any, x: any) => void +>x : any +>x : any + +var f4 = (x: T, x: T) => { } +>f4 : (x: T, x: T) => void +>(x: T, x: T) => { } : (x: T, x: T) => void +>T : T +>x : T +>T : T +>x : T +>T : T + +function foo2(x: string, x: number) { } +>foo2 : (x: string, x: number) => void +>x : string +>x : number + +var f5 = function foo(x: string, x: number) { } +>f5 : (x: string, x: number) => void +>function foo(x: string, x: number) { } : (x: string, x: number) => void +>foo : (x: string, x: number) => void +>x : string +>x : number + +var f6 = function (x: string, x: number) { } +>f6 : (x: string, x: number) => void +>function (x: string, x: number) { } : (x: string, x: number) => void +>x : string +>x : number + +var f7 = (x: string, x: number) => { } +>f7 : (x: string, x: number) => void +>(x: string, x: number) => { } : (x: string, x: number) => void +>x : string +>x : number + +var f8 = (x: T, y: T) => { } +>f8 : (x: T, y: T) => void +>(x: T, y: T) => { } : (x: T, y: T) => void +>T : T +>x : T +>T : T +>y : T +>T : T + +class C { +>C : C + + foo(x, x) { } +>foo : (x: any, x: any) => void +>x : any +>x : any + + foo2(x: number, x: string) { } +>foo2 : (x: number, x: string) => void +>x : number +>x : string + + foo3(x: T, x: T) { } +>foo3 : (x: T, x: T) => void +>T : T +>x : T +>T : T +>x : T +>T : T +} + +interface I { +>I : I + + (x, x); +>x : any +>x : any + + (x: string, x: number); +>x : string +>x : number + + foo(x, x); +>foo : { (x: any, x: any): any; (x: number, x: string): any; } +>x : any +>x : any + + foo(x: number, x: string); +>foo : { (x: any, x: any): any; (x: number, x: string): any; } +>x : number +>x : string + + foo3(x: T, x: T); +>foo3 : (x: T, x: T) => any +>T : T +>x : T +>T : T +>x : T +>T : T +} + +var a: { +>a : { foo(x: any, x: any): any; foo2(x: number, x: string): any; } + + foo(x, x); +>foo : (x: any, x: any) => any +>x : any +>x : any + + foo2(x: number, x: string); +>foo2 : (x: number, x: string) => any +>x : number +>x : string + +}; + +var b = { +>b : { foo(x: any, x: any): void; a: (x: number, x: string) => void; b: (x: T, x: T) => void; } +>{ foo(x, x) { }, a: function foo(x: number, x: string) { }, b: (x: T, x: T) => { }} : { foo(x: any, x: any): void; a: (x: number, x: string) => void; b: (x: T, x: T) => void; } + + foo(x, x) { }, +>foo : (x: any, x: any) => void +>x : any +>x : any + + a: function foo(x: number, x: string) { }, +>a : (x: number, x: string) => void +>function foo(x: number, x: string) { } : (x: number, x: string) => void +>foo : (x: number, x: string) => void +>x : number +>x : string + + b: (x: T, x: T) => { } +>b : (x: T, x: T) => void +>(x: T, x: T) => { } : (x: T, x: T) => void +>T : T +>x : T +>T : T +>x : T +>T : T +} diff --git a/tests/baselines/reference/callSignaturesWithParameterInitializers.symbols b/tests/baselines/reference/callSignaturesWithParameterInitializers.symbols new file mode 100644 index 00000000000..270d5562a04 --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithParameterInitializers.symbols @@ -0,0 +1,166 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithParameterInitializers.ts === +// Optional parameters allow initializers only in implementation signatures + +function foo(x = 1) { } +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 0, 0)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 2, 13)) + +var f = function foo(x = 1) { } +>f : Symbol(f, Decl(callSignaturesWithParameterInitializers.ts, 3, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 3, 7)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 3, 21)) + +var f2 = (x: number, y = 1) => { } +>f2 : Symbol(f2, Decl(callSignaturesWithParameterInitializers.ts, 4, 3)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 4, 10)) +>y : Symbol(y, Decl(callSignaturesWithParameterInitializers.ts, 4, 20)) + +foo(1); +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 0, 0)) + +foo(); +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 0, 0)) + +f(1); +>f : Symbol(f, Decl(callSignaturesWithParameterInitializers.ts, 3, 3)) + +f(); +>f : Symbol(f, Decl(callSignaturesWithParameterInitializers.ts, 3, 3)) + +f2(1); +>f2 : Symbol(f2, Decl(callSignaturesWithParameterInitializers.ts, 4, 3)) + +f2(1, 2); +>f2 : Symbol(f2, Decl(callSignaturesWithParameterInitializers.ts, 4, 3)) + +class C { +>C : Symbol(C, Decl(callSignaturesWithParameterInitializers.ts, 11, 9)) + + foo(x = 1) { } +>foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers.ts, 13, 9)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 14, 8)) +} + +var c: C; +>c : Symbol(c, Decl(callSignaturesWithParameterInitializers.ts, 17, 3)) +>C : Symbol(C, Decl(callSignaturesWithParameterInitializers.ts, 11, 9)) + +c.foo(); +>c.foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers.ts, 13, 9)) +>c : Symbol(c, Decl(callSignaturesWithParameterInitializers.ts, 17, 3)) +>foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers.ts, 13, 9)) + +c.foo(1); +>c.foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers.ts, 13, 9)) +>c : Symbol(c, Decl(callSignaturesWithParameterInitializers.ts, 17, 3)) +>foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers.ts, 13, 9)) + +// these are errors +interface I { +>I : Symbol(I, Decl(callSignaturesWithParameterInitializers.ts, 19, 9)) + + (x = 1); +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 23, 5)) + + foo(x: number, y = 1); +>foo : Symbol(I.foo, Decl(callSignaturesWithParameterInitializers.ts, 23, 12)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 24, 8)) +>y : Symbol(y, Decl(callSignaturesWithParameterInitializers.ts, 24, 18)) +} + +var i: I; +>i : Symbol(i, Decl(callSignaturesWithParameterInitializers.ts, 27, 3)) +>I : Symbol(I, Decl(callSignaturesWithParameterInitializers.ts, 19, 9)) + +i(); +>i : Symbol(i, Decl(callSignaturesWithParameterInitializers.ts, 27, 3)) + +i(1); +>i : Symbol(i, Decl(callSignaturesWithParameterInitializers.ts, 27, 3)) + +i.foo(1); +>i.foo : Symbol(I.foo, Decl(callSignaturesWithParameterInitializers.ts, 23, 12)) +>i : Symbol(i, Decl(callSignaturesWithParameterInitializers.ts, 27, 3)) +>foo : Symbol(I.foo, Decl(callSignaturesWithParameterInitializers.ts, 23, 12)) + +i.foo(1, 2); +>i.foo : Symbol(I.foo, Decl(callSignaturesWithParameterInitializers.ts, 23, 12)) +>i : Symbol(i, Decl(callSignaturesWithParameterInitializers.ts, 27, 3)) +>foo : Symbol(I.foo, Decl(callSignaturesWithParameterInitializers.ts, 23, 12)) + +// these are errors +var a: { +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 34, 3)) + + (x = 1); +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 35, 5)) + + foo(x = 1); +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 35, 12)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 36, 8)) +} + +a(); +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 34, 3)) + +a(1); +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 34, 3)) + +a.foo(); +>a.foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 35, 12)) +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 34, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 35, 12)) + +a.foo(1); +>a.foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 35, 12)) +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 34, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 35, 12)) + +var b = { +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 44, 3)) + + foo(x = 1) { }, +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 44, 9)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 45, 8)) + + a: function foo(x: number, y = 1) { }, +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 45, 19)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 46, 6)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 46, 20)) +>y : Symbol(y, Decl(callSignaturesWithParameterInitializers.ts, 46, 30)) + + b: (x = 1) => { } +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 46, 42)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers.ts, 47, 8)) +} + +b.foo(); +>b.foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 44, 9)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 44, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 44, 9)) + +b.foo(1); +>b.foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 44, 9)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 44, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers.ts, 44, 9)) + +b.a(1); +>b.a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 45, 19)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 44, 3)) +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 45, 19)) + +b.a(1, 2); +>b.a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 45, 19)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 44, 3)) +>a : Symbol(a, Decl(callSignaturesWithParameterInitializers.ts, 45, 19)) + +b.b(); +>b.b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 46, 42)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 44, 3)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 46, 42)) + +b.b(1); +>b.b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 46, 42)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 44, 3)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers.ts, 46, 42)) + diff --git a/tests/baselines/reference/callSignaturesWithParameterInitializers.types b/tests/baselines/reference/callSignaturesWithParameterInitializers.types new file mode 100644 index 00000000000..41e28dedaab --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithParameterInitializers.types @@ -0,0 +1,221 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithParameterInitializers.ts === +// Optional parameters allow initializers only in implementation signatures + +function foo(x = 1) { } +>foo : (x?: number) => void +>x : number +>1 : 1 + +var f = function foo(x = 1) { } +>f : (x?: number) => void +>function foo(x = 1) { } : (x?: number) => void +>foo : (x?: number) => void +>x : number +>1 : 1 + +var f2 = (x: number, y = 1) => { } +>f2 : (x: number, y?: number) => void +>(x: number, y = 1) => { } : (x: number, y?: number) => void +>x : number +>y : number +>1 : 1 + +foo(1); +>foo(1) : void +>foo : (x?: number) => void +>1 : 1 + +foo(); +>foo() : void +>foo : (x?: number) => void + +f(1); +>f(1) : void +>f : (x?: number) => void +>1 : 1 + +f(); +>f() : void +>f : (x?: number) => void + +f2(1); +>f2(1) : void +>f2 : (x: number, y?: number) => void +>1 : 1 + +f2(1, 2); +>f2(1, 2) : void +>f2 : (x: number, y?: number) => void +>1 : 1 +>2 : 2 + +class C { +>C : C + + foo(x = 1) { } +>foo : (x?: number) => void +>x : number +>1 : 1 +} + +var c: C; +>c : C +>C : C + +c.foo(); +>c.foo() : void +>c.foo : (x?: number) => void +>c : C +>foo : (x?: number) => void + +c.foo(1); +>c.foo(1) : void +>c.foo : (x?: number) => void +>c : C +>foo : (x?: number) => void +>1 : 1 + +// these are errors +interface I { +>I : I + + (x = 1); +>x : number +>1 : 1 + + foo(x: number, y = 1); +>foo : (x: number, y?: number) => any +>x : number +>y : number +>1 : 1 +} + +var i: I; +>i : I +>I : I + +i(); +>i() : any +>i : I + +i(1); +>i(1) : any +>i : I +>1 : 1 + +i.foo(1); +>i.foo(1) : any +>i.foo : (x: number, y?: number) => any +>i : I +>foo : (x: number, y?: number) => any +>1 : 1 + +i.foo(1, 2); +>i.foo(1, 2) : any +>i.foo : (x: number, y?: number) => any +>i : I +>foo : (x: number, y?: number) => any +>1 : 1 +>2 : 2 + +// these are errors +var a: { +>a : { (x?: number): any; foo(x?: number): any; } + + (x = 1); +>x : number +>1 : 1 + + foo(x = 1); +>foo : (x?: number) => any +>x : number +>1 : 1 +} + +a(); +>a() : any +>a : { (x?: number): any; foo(x?: number): any; } + +a(1); +>a(1) : any +>a : { (x?: number): any; foo(x?: number): any; } +>1 : 1 + +a.foo(); +>a.foo() : any +>a.foo : (x?: number) => any +>a : { (x?: number): any; foo(x?: number): any; } +>foo : (x?: number) => any + +a.foo(1); +>a.foo(1) : any +>a.foo : (x?: number) => any +>a : { (x?: number): any; foo(x?: number): any; } +>foo : (x?: number) => any +>1 : 1 + +var b = { +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } +>{ foo(x = 1) { }, a: function foo(x: number, y = 1) { }, b: (x = 1) => { }} : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } + + foo(x = 1) { }, +>foo : (x?: number) => void +>x : number +>1 : 1 + + a: function foo(x: number, y = 1) { }, +>a : (x: number, y?: number) => void +>function foo(x: number, y = 1) { } : (x: number, y?: number) => void +>foo : (x: number, y?: number) => void +>x : number +>y : number +>1 : 1 + + b: (x = 1) => { } +>b : (x?: number) => void +>(x = 1) => { } : (x?: number) => void +>x : number +>1 : 1 +} + +b.foo(); +>b.foo() : void +>b.foo : (x?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } +>foo : (x?: number) => void + +b.foo(1); +>b.foo(1) : void +>b.foo : (x?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } +>foo : (x?: number) => void +>1 : 1 + +b.a(1); +>b.a(1) : void +>b.a : (x: number, y?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } +>a : (x: number, y?: number) => void +>1 : 1 + +b.a(1, 2); +>b.a(1, 2) : void +>b.a : (x: number, y?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } +>a : (x: number, y?: number) => void +>1 : 1 +>2 : 2 + +b.b(); +>b.b() : void +>b.b : (x?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } +>b : (x?: number) => void + +b.b(1); +>b.b(1) : void +>b.b : (x?: number) => void +>b : { foo(x?: number): void; a: (x: number, y?: number) => void; b: (x?: number) => void; } +>b : (x?: number) => void +>1 : 1 + diff --git a/tests/baselines/reference/callSignaturesWithParameterInitializers2.symbols b/tests/baselines/reference/callSignaturesWithParameterInitializers2.symbols new file mode 100644 index 00000000000..12f4aeb5ed3 --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithParameterInitializers2.symbols @@ -0,0 +1,66 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithParameterInitializers2.ts === +// Optional parameters allow initializers only in implementation signatures +// All the below declarations are errors + +function foo(x = 2); +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 0, 0), Decl(callSignaturesWithParameterInitializers2.ts, 3, 20)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers2.ts, 3, 13)) + +function foo(x = 1) { } +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 0, 0), Decl(callSignaturesWithParameterInitializers2.ts, 3, 20)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers2.ts, 4, 13)) + +foo(1); +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 0, 0), Decl(callSignaturesWithParameterInitializers2.ts, 3, 20)) + +foo(); +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 0, 0), Decl(callSignaturesWithParameterInitializers2.ts, 3, 20)) + +class C { +>C : Symbol(C, Decl(callSignaturesWithParameterInitializers2.ts, 7, 6)) + + foo(x = 2); +>foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers2.ts, 9, 9), Decl(callSignaturesWithParameterInitializers2.ts, 10, 15)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers2.ts, 10, 8)) + + foo(x = 1) { } +>foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers2.ts, 9, 9), Decl(callSignaturesWithParameterInitializers2.ts, 10, 15)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers2.ts, 11, 8)) +} + +var c: C; +>c : Symbol(c, Decl(callSignaturesWithParameterInitializers2.ts, 14, 3)) +>C : Symbol(C, Decl(callSignaturesWithParameterInitializers2.ts, 7, 6)) + +c.foo(); +>c.foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers2.ts, 9, 9), Decl(callSignaturesWithParameterInitializers2.ts, 10, 15)) +>c : Symbol(c, Decl(callSignaturesWithParameterInitializers2.ts, 14, 3)) +>foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers2.ts, 9, 9), Decl(callSignaturesWithParameterInitializers2.ts, 10, 15)) + +c.foo(1); +>c.foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers2.ts, 9, 9), Decl(callSignaturesWithParameterInitializers2.ts, 10, 15)) +>c : Symbol(c, Decl(callSignaturesWithParameterInitializers2.ts, 14, 3)) +>foo : Symbol(C.foo, Decl(callSignaturesWithParameterInitializers2.ts, 9, 9), Decl(callSignaturesWithParameterInitializers2.ts, 10, 15)) + +var b = { +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers2.ts, 18, 3)) + + foo(x = 1), // error +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 18, 9), Decl(callSignaturesWithParameterInitializers2.ts, 19, 15)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers2.ts, 19, 8)) + + foo(x = 1) { }, // error +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 18, 9), Decl(callSignaturesWithParameterInitializers2.ts, 19, 15)) +>x : Symbol(x, Decl(callSignaturesWithParameterInitializers2.ts, 20, 8)) +} + +b.foo(); +>b.foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 18, 9), Decl(callSignaturesWithParameterInitializers2.ts, 19, 15)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers2.ts, 18, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 18, 9), Decl(callSignaturesWithParameterInitializers2.ts, 19, 15)) + +b.foo(1); +>b.foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 18, 9), Decl(callSignaturesWithParameterInitializers2.ts, 19, 15)) +>b : Symbol(b, Decl(callSignaturesWithParameterInitializers2.ts, 18, 3)) +>foo : Symbol(foo, Decl(callSignaturesWithParameterInitializers2.ts, 18, 9), Decl(callSignaturesWithParameterInitializers2.ts, 19, 15)) + diff --git a/tests/baselines/reference/callSignaturesWithParameterInitializers2.types b/tests/baselines/reference/callSignaturesWithParameterInitializers2.types new file mode 100644 index 00000000000..b83c202eff6 --- /dev/null +++ b/tests/baselines/reference/callSignaturesWithParameterInitializers2.types @@ -0,0 +1,82 @@ +=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignaturesWithParameterInitializers2.ts === +// Optional parameters allow initializers only in implementation signatures +// All the below declarations are errors + +function foo(x = 2); +>foo : (x?: number) => any +>x : number +>2 : 2 + +function foo(x = 1) { } +>foo : (x?: number) => any +>x : number +>1 : 1 + +foo(1); +>foo(1) : any +>foo : (x?: number) => any +>1 : 1 + +foo(); +>foo() : any +>foo : (x?: number) => any + +class C { +>C : C + + foo(x = 2); +>foo : (x?: number) => any +>x : number +>2 : 2 + + foo(x = 1) { } +>foo : (x?: number) => any +>x : number +>1 : 1 +} + +var c: C; +>c : C +>C : C + +c.foo(); +>c.foo() : any +>c.foo : (x?: number) => any +>c : C +>foo : (x?: number) => any + +c.foo(1); +>c.foo(1) : any +>c.foo : (x?: number) => any +>c : C +>foo : (x?: number) => any +>1 : 1 + +var b = { +>b : { foo(x?: number): any; foo(x?: number): void; } +>{ foo(x = 1), // error foo(x = 1) { }, // error} : { foo(x?: number): any; foo(x?: number): void; } + + foo(x = 1), // error +>foo : { (x?: number): any; (x?: number): void; } +>x : number +>1 : 1 + + foo(x = 1) { }, // error +>foo : { (x?: number): any; (x?: number): void; } +>x : number +>1 : 1 +} + +b.foo(); +>b.foo() : any +>b.foo : { (x?: number): any; (x?: number): void; } +>b : { foo(x?: number): any; foo(x?: number): void; } +>foo : { (x?: number): any; (x?: number): void; } + +b.foo(1); +>b.foo(1) : any +>b.foo : { (x?: number): any; (x?: number): void; } +>b : { foo(x?: number): any; foo(x?: number): void; } +>foo : { (x?: number): any; (x?: number): void; } +>1 : 1 + diff --git a/tests/baselines/reference/callWithSpread2.symbols b/tests/baselines/reference/callWithSpread2.symbols new file mode 100644 index 00000000000..169e8c8d47e --- /dev/null +++ b/tests/baselines/reference/callWithSpread2.symbols @@ -0,0 +1,128 @@ +=== tests/cases/conformance/expressions/functionCalls/callWithSpread2.ts === +declare function all(a?: number, b?: number): void; +>all : Symbol(all, Decl(callWithSpread2.ts, 0, 0)) +>a : Symbol(a, Decl(callWithSpread2.ts, 0, 21)) +>b : Symbol(b, Decl(callWithSpread2.ts, 0, 32)) + +declare function weird(a?: number | string, b?: number | string): void; +>weird : Symbol(weird, Decl(callWithSpread2.ts, 0, 51)) +>a : Symbol(a, Decl(callWithSpread2.ts, 1, 23)) +>b : Symbol(b, Decl(callWithSpread2.ts, 1, 43)) + +declare function prefix(s: string, a?: number, b?: number): void; +>prefix : Symbol(prefix, Decl(callWithSpread2.ts, 1, 71)) +>s : Symbol(s, Decl(callWithSpread2.ts, 2, 24)) +>a : Symbol(a, Decl(callWithSpread2.ts, 2, 34)) +>b : Symbol(b, Decl(callWithSpread2.ts, 2, 46)) + +declare function rest(s: string, a?: number, b?: number, ...rest: number[]): void; +>rest : Symbol(rest, Decl(callWithSpread2.ts, 2, 65)) +>s : Symbol(s, Decl(callWithSpread2.ts, 3, 22)) +>a : Symbol(a, Decl(callWithSpread2.ts, 3, 32)) +>b : Symbol(b, Decl(callWithSpread2.ts, 3, 44)) +>rest : Symbol(rest, Decl(callWithSpread2.ts, 3, 56)) + +declare function normal(s: string): void; +>normal : Symbol(normal, Decl(callWithSpread2.ts, 3, 83)) +>s : Symbol(s, Decl(callWithSpread2.ts, 4, 24)) + +declare function thunk(): string; +>thunk : Symbol(thunk, Decl(callWithSpread2.ts, 4, 41)) + +declare var ns: number[]; +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + +declare var mixed: (number | string)[]; +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +declare var tuple: [number, string]; +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + +// good +all(...ns) +>all : Symbol(all, Decl(callWithSpread2.ts, 0, 0)) +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + +weird(...ns) +>weird : Symbol(weird, Decl(callWithSpread2.ts, 0, 51)) +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + +weird(...mixed) +>weird : Symbol(weird, Decl(callWithSpread2.ts, 0, 51)) +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +weird(...tuple) +>weird : Symbol(weird, Decl(callWithSpread2.ts, 0, 51)) +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + +prefix("a", ...ns) +>prefix : Symbol(prefix, Decl(callWithSpread2.ts, 1, 71)) +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + +rest("d", ...ns) +>rest : Symbol(rest, Decl(callWithSpread2.ts, 2, 65)) +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + + +// this covers the arguments case +normal("g", ...ns) +>normal : Symbol(normal, Decl(callWithSpread2.ts, 3, 83)) +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + +normal("h", ...mixed) +>normal : Symbol(normal, Decl(callWithSpread2.ts, 3, 83)) +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +normal("i", ...tuple) +>normal : Symbol(normal, Decl(callWithSpread2.ts, 3, 83)) +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + +thunk(...ns) +>thunk : Symbol(thunk, Decl(callWithSpread2.ts, 4, 41)) +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + +thunk(...mixed) +>thunk : Symbol(thunk, Decl(callWithSpread2.ts, 4, 41)) +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +thunk(...tuple) +>thunk : Symbol(thunk, Decl(callWithSpread2.ts, 4, 41)) +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + +// bad +all(...mixed) +>all : Symbol(all, Decl(callWithSpread2.ts, 0, 0)) +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +all(...tuple) +>all : Symbol(all, Decl(callWithSpread2.ts, 0, 0)) +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + +prefix("b", ...mixed) +>prefix : Symbol(prefix, Decl(callWithSpread2.ts, 1, 71)) +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +prefix("c", ...tuple) +>prefix : Symbol(prefix, Decl(callWithSpread2.ts, 1, 71)) +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + +rest("e", ...mixed) +>rest : Symbol(rest, Decl(callWithSpread2.ts, 2, 65)) +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +rest("f", ...tuple) +>rest : Symbol(rest, Decl(callWithSpread2.ts, 2, 65)) +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + +prefix(...ns) // required parameters are required +>prefix : Symbol(prefix, Decl(callWithSpread2.ts, 1, 71)) +>ns : Symbol(ns, Decl(callWithSpread2.ts, 7, 11)) + +prefix(...mixed) +>prefix : Symbol(prefix, Decl(callWithSpread2.ts, 1, 71)) +>mixed : Symbol(mixed, Decl(callWithSpread2.ts, 8, 11)) + +prefix(...tuple) +>prefix : Symbol(prefix, Decl(callWithSpread2.ts, 1, 71)) +>tuple : Symbol(tuple, Decl(callWithSpread2.ts, 9, 11)) + diff --git a/tests/baselines/reference/callWithSpread2.types b/tests/baselines/reference/callWithSpread2.types new file mode 100644 index 00000000000..75f0f18d287 --- /dev/null +++ b/tests/baselines/reference/callWithSpread2.types @@ -0,0 +1,179 @@ +=== tests/cases/conformance/expressions/functionCalls/callWithSpread2.ts === +declare function all(a?: number, b?: number): void; +>all : (a?: number, b?: number) => void +>a : number +>b : number + +declare function weird(a?: number | string, b?: number | string): void; +>weird : (a?: string | number, b?: string | number) => void +>a : string | number +>b : string | number + +declare function prefix(s: string, a?: number, b?: number): void; +>prefix : (s: string, a?: number, b?: number) => void +>s : string +>a : number +>b : number + +declare function rest(s: string, a?: number, b?: number, ...rest: number[]): void; +>rest : (s: string, a?: number, b?: number, ...rest: number[]) => void +>s : string +>a : number +>b : number +>rest : number[] + +declare function normal(s: string): void; +>normal : (s: string) => void +>s : string + +declare function thunk(): string; +>thunk : () => string + +declare var ns: number[]; +>ns : number[] + +declare var mixed: (number | string)[]; +>mixed : (string | number)[] + +declare var tuple: [number, string]; +>tuple : [number, string] + +// good +all(...ns) +>all(...ns) : void +>all : (a?: number, b?: number) => void +>...ns : number +>ns : number[] + +weird(...ns) +>weird(...ns) : void +>weird : (a?: string | number, b?: string | number) => void +>...ns : number +>ns : number[] + +weird(...mixed) +>weird(...mixed) : void +>weird : (a?: string | number, b?: string | number) => void +>...mixed : string | number +>mixed : (string | number)[] + +weird(...tuple) +>weird(...tuple) : void +>weird : (a?: string | number, b?: string | number) => void +>...tuple : string | number +>tuple : [number, string] + +prefix("a", ...ns) +>prefix("a", ...ns) : void +>prefix : (s: string, a?: number, b?: number) => void +>"a" : "a" +>...ns : number +>ns : number[] + +rest("d", ...ns) +>rest("d", ...ns) : void +>rest : (s: string, a?: number, b?: number, ...rest: number[]) => void +>"d" : "d" +>...ns : number +>ns : number[] + + +// this covers the arguments case +normal("g", ...ns) +>normal("g", ...ns) : void +>normal : (s: string) => void +>"g" : "g" +>...ns : number +>ns : number[] + +normal("h", ...mixed) +>normal("h", ...mixed) : void +>normal : (s: string) => void +>"h" : "h" +>...mixed : string | number +>mixed : (string | number)[] + +normal("i", ...tuple) +>normal("i", ...tuple) : void +>normal : (s: string) => void +>"i" : "i" +>...tuple : string | number +>tuple : [number, string] + +thunk(...ns) +>thunk(...ns) : string +>thunk : () => string +>...ns : number +>ns : number[] + +thunk(...mixed) +>thunk(...mixed) : string +>thunk : () => string +>...mixed : string | number +>mixed : (string | number)[] + +thunk(...tuple) +>thunk(...tuple) : string +>thunk : () => string +>...tuple : string | number +>tuple : [number, string] + +// bad +all(...mixed) +>all(...mixed) : void +>all : (a?: number, b?: number) => void +>...mixed : string | number +>mixed : (string | number)[] + +all(...tuple) +>all(...tuple) : void +>all : (a?: number, b?: number) => void +>...tuple : string | number +>tuple : [number, string] + +prefix("b", ...mixed) +>prefix("b", ...mixed) : void +>prefix : (s: string, a?: number, b?: number) => void +>"b" : "b" +>...mixed : string | number +>mixed : (string | number)[] + +prefix("c", ...tuple) +>prefix("c", ...tuple) : void +>prefix : (s: string, a?: number, b?: number) => void +>"c" : "c" +>...tuple : string | number +>tuple : [number, string] + +rest("e", ...mixed) +>rest("e", ...mixed) : void +>rest : (s: string, a?: number, b?: number, ...rest: number[]) => void +>"e" : "e" +>...mixed : string | number +>mixed : (string | number)[] + +rest("f", ...tuple) +>rest("f", ...tuple) : void +>rest : (s: string, a?: number, b?: number, ...rest: number[]) => void +>"f" : "f" +>...tuple : string | number +>tuple : [number, string] + +prefix(...ns) // required parameters are required +>prefix(...ns) : void +>prefix : (s: string, a?: number, b?: number) => void +>...ns : number +>ns : number[] + +prefix(...mixed) +>prefix(...mixed) : void +>prefix : (s: string, a?: number, b?: number) => void +>...mixed : string | number +>mixed : (string | number)[] + +prefix(...tuple) +>prefix(...tuple) : void +>prefix : (s: string, a?: number, b?: number) => void +>...tuple : string | number +>tuple : [number, string] + diff --git a/tests/baselines/reference/callWithWrongNumberOfTypeArguments.symbols b/tests/baselines/reference/callWithWrongNumberOfTypeArguments.symbols new file mode 100644 index 00000000000..ad721c454b9 --- /dev/null +++ b/tests/baselines/reference/callWithWrongNumberOfTypeArguments.symbols @@ -0,0 +1,15 @@ +=== tests/cases/compiler/callWithWrongNumberOfTypeArguments.ts === +function f() { } +>f : Symbol(f, Decl(callWithWrongNumberOfTypeArguments.ts, 0, 0)) +>T : Symbol(T, Decl(callWithWrongNumberOfTypeArguments.ts, 0, 11)) +>U : Symbol(U, Decl(callWithWrongNumberOfTypeArguments.ts, 0, 13)) + +f(); +>f : Symbol(f, Decl(callWithWrongNumberOfTypeArguments.ts, 0, 0)) + +f(); +>f : Symbol(f, Decl(callWithWrongNumberOfTypeArguments.ts, 0, 0)) + +f(); +>f : Symbol(f, Decl(callWithWrongNumberOfTypeArguments.ts, 0, 0)) + diff --git a/tests/baselines/reference/callWithWrongNumberOfTypeArguments.types b/tests/baselines/reference/callWithWrongNumberOfTypeArguments.types new file mode 100644 index 00000000000..0056a0d3e9a --- /dev/null +++ b/tests/baselines/reference/callWithWrongNumberOfTypeArguments.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/callWithWrongNumberOfTypeArguments.ts === +function f() { } +>f : () => void +>T : T +>U : U + +f(); +>f() : any +>f : () => void + +f(); +>f() : void +>f : () => void + +f(); +>f() : any +>f : () => void + diff --git a/tests/baselines/reference/callbackArgsDifferByOptionality.symbols b/tests/baselines/reference/callbackArgsDifferByOptionality.symbols new file mode 100644 index 00000000000..283d414b61b --- /dev/null +++ b/tests/baselines/reference/callbackArgsDifferByOptionality.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/callbackArgsDifferByOptionality.ts === +function x3(callback: (x?: 'hi') => number); +>x3 : Symbol(x3, Decl(callbackArgsDifferByOptionality.ts, 0, 0), Decl(callbackArgsDifferByOptionality.ts, 0, 44), Decl(callbackArgsDifferByOptionality.ts, 1, 45)) +>callback : Symbol(callback, Decl(callbackArgsDifferByOptionality.ts, 0, 12)) +>x : Symbol(x, Decl(callbackArgsDifferByOptionality.ts, 0, 23)) + +function x3(callback: (x: string) => number); +>x3 : Symbol(x3, Decl(callbackArgsDifferByOptionality.ts, 0, 0), Decl(callbackArgsDifferByOptionality.ts, 0, 44), Decl(callbackArgsDifferByOptionality.ts, 1, 45)) +>callback : Symbol(callback, Decl(callbackArgsDifferByOptionality.ts, 1, 12)) +>x : Symbol(x, Decl(callbackArgsDifferByOptionality.ts, 1, 23)) + +function x3(callback: (x: any) => number) { +>x3 : Symbol(x3, Decl(callbackArgsDifferByOptionality.ts, 0, 0), Decl(callbackArgsDifferByOptionality.ts, 0, 44), Decl(callbackArgsDifferByOptionality.ts, 1, 45)) +>callback : Symbol(callback, Decl(callbackArgsDifferByOptionality.ts, 2, 12)) +>x : Symbol(x, Decl(callbackArgsDifferByOptionality.ts, 2, 23)) + + cb(); +} diff --git a/tests/baselines/reference/callbackArgsDifferByOptionality.types b/tests/baselines/reference/callbackArgsDifferByOptionality.types new file mode 100644 index 00000000000..d54360c0656 --- /dev/null +++ b/tests/baselines/reference/callbackArgsDifferByOptionality.types @@ -0,0 +1,20 @@ +=== tests/cases/compiler/callbackArgsDifferByOptionality.ts === +function x3(callback: (x?: 'hi') => number); +>x3 : { (callback: (x?: "hi") => number): any; (callback: (x: string) => number): any; } +>callback : (x?: "hi") => number +>x : "hi" + +function x3(callback: (x: string) => number); +>x3 : { (callback: (x?: "hi") => number): any; (callback: (x: string) => number): any; } +>callback : (x: string) => number +>x : string + +function x3(callback: (x: any) => number) { +>x3 : { (callback: (x?: "hi") => number): any; (callback: (x: string) => number): any; } +>callback : (x: any) => number +>x : any + + cb(); +>cb() : any +>cb : any +} diff --git a/tests/baselines/reference/cannotInvokeNewOnErrorExpression.symbols b/tests/baselines/reference/cannotInvokeNewOnErrorExpression.symbols new file mode 100644 index 00000000000..fb87705371b --- /dev/null +++ b/tests/baselines/reference/cannotInvokeNewOnErrorExpression.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/cannotInvokeNewOnErrorExpression.ts === +module M +>M : Symbol(M, Decl(cannotInvokeNewOnErrorExpression.ts, 0, 0)) +{ + class ClassA {} +>ClassA : Symbol(ClassA, Decl(cannotInvokeNewOnErrorExpression.ts, 1, 1)) +} +var t = new M.ClassA[]; +>t : Symbol(t, Decl(cannotInvokeNewOnErrorExpression.ts, 4, 3)) +>M : Symbol(M, Decl(cannotInvokeNewOnErrorExpression.ts, 0, 0)) + diff --git a/tests/baselines/reference/cannotInvokeNewOnErrorExpression.types b/tests/baselines/reference/cannotInvokeNewOnErrorExpression.types new file mode 100644 index 00000000000..47ccb421623 --- /dev/null +++ b/tests/baselines/reference/cannotInvokeNewOnErrorExpression.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/cannotInvokeNewOnErrorExpression.ts === +module M +>M : typeof M +{ + class ClassA {} +>ClassA : ClassA +} +var t = new M.ClassA[]; +>t : any +>new M.ClassA[] : any +>M.ClassA[] : any +>M.ClassA : any +>M : typeof M +>ClassA : any + diff --git a/tests/baselines/reference/cannotInvokeNewOnIndexExpression.symbols b/tests/baselines/reference/cannotInvokeNewOnIndexExpression.symbols new file mode 100644 index 00000000000..7ac266b2728 --- /dev/null +++ b/tests/baselines/reference/cannotInvokeNewOnIndexExpression.symbols @@ -0,0 +1,4 @@ +=== tests/cases/compiler/cannotInvokeNewOnIndexExpression.ts === +var test: any[] = new any[1]; +>test : Symbol(test, Decl(cannotInvokeNewOnIndexExpression.ts, 0, 3)) + diff --git a/tests/baselines/reference/cannotInvokeNewOnIndexExpression.types b/tests/baselines/reference/cannotInvokeNewOnIndexExpression.types new file mode 100644 index 00000000000..ec1a2b6dda1 --- /dev/null +++ b/tests/baselines/reference/cannotInvokeNewOnIndexExpression.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/cannotInvokeNewOnIndexExpression.ts === +var test: any[] = new any[1]; +>test : any[] +>new any[1] : any +>any[1] : any +>any : any +>1 : 1 + diff --git a/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.symbols b/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.symbols new file mode 100644 index 00000000000..a2cad82ec4e --- /dev/null +++ b/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.symbols @@ -0,0 +1,23 @@ +=== tests/cases/compiler/captureSuperPropertyAccessInSuperCall01.ts === +class A { +>A : Symbol(A, Decl(captureSuperPropertyAccessInSuperCall01.ts, 0, 0)) + + constructor(f: () => string) { +>f : Symbol(f, Decl(captureSuperPropertyAccessInSuperCall01.ts, 1, 13)) + } + public blah(): string { return ""; } +>blah : Symbol(A.blah, Decl(captureSuperPropertyAccessInSuperCall01.ts, 2, 2)) +} + +class B extends A { +>B : Symbol(B, Decl(captureSuperPropertyAccessInSuperCall01.ts, 4, 1)) +>A : Symbol(A, Decl(captureSuperPropertyAccessInSuperCall01.ts, 0, 0)) + + constructor() { + super(() => { return super.blah(); }) +>super : Symbol(A, Decl(captureSuperPropertyAccessInSuperCall01.ts, 0, 0)) +>super.blah : Symbol(A.blah, Decl(captureSuperPropertyAccessInSuperCall01.ts, 2, 2)) +>super : Symbol(A, Decl(captureSuperPropertyAccessInSuperCall01.ts, 0, 0)) +>blah : Symbol(A.blah, Decl(captureSuperPropertyAccessInSuperCall01.ts, 2, 2)) + } +} diff --git a/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.types b/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.types new file mode 100644 index 00000000000..154d018eb42 --- /dev/null +++ b/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/captureSuperPropertyAccessInSuperCall01.ts === +class A { +>A : A + + constructor(f: () => string) { +>f : () => string + } + public blah(): string { return ""; } +>blah : () => string +>"" : "" +} + +class B extends A { +>B : B +>A : A + + constructor() { + super(() => { return super.blah(); }) +>super(() => { return super.blah(); }) : void +>super : typeof A +>() => { return super.blah(); } : () => string +>super.blah() : string +>super.blah : () => string +>super : A +>blah : () => string + } +} diff --git a/tests/baselines/reference/capturedLetConstInLoop5.types b/tests/baselines/reference/capturedLetConstInLoop5.types index 098a1ce70a4..3ec96ca37da 100644 --- a/tests/baselines/reference/capturedLetConstInLoop5.types +++ b/tests/baselines/reference/capturedLetConstInLoop5.types @@ -92,10 +92,10 @@ function foo1(x) { for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -143,7 +143,7 @@ function foo2(x) { let x = 1; >x : number ->1 : number +>1 : 1 var v = x; >v : number @@ -227,10 +227,10 @@ function foo4(x) { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number @@ -240,7 +240,7 @@ function foo4(x) { let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + v }); >(function() { return x + v }) : () => number @@ -277,12 +277,12 @@ function foo5(x) { for (let x = 0, y = 1; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >y : number ->1 : number +>1 : 1 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -430,16 +430,16 @@ function foo8(x) { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 var v = x; >v : number @@ -566,33 +566,33 @@ function foo1_c(x) { >x : any for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 var v = x; >v : number ->x : number +>x : 0 (function() { return x + v }); >(function() { return x + v }) : () => number >function() { return x + v } : () => number >x + v : number ->x : number +>x : 0 >v : number (() => x + v); >(() => x + v) : () => number >() => x + v : () => number >x + v : number ->x : number +>x : 0 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 return; @@ -615,30 +615,30 @@ function foo2_c(x) { >1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + v }); >(function() { return x + v }) : () => number >function() { return x + v } : () => number >x + v : number ->x : number +>x : 1 >v : number (() => x + v); >(() => x + v) : () => number >() => x + v : () => number >x + v : number ->x : number +>x : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -657,8 +657,8 @@ function foo3_c(x) { do { const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 var v; >v : any @@ -667,19 +667,19 @@ function foo3_c(x) { >(function() { return x + v }) : () => any >function() { return x + v } : () => any >x + v : any ->x : number +>x : 1 >v : any (() => x + v); >(() => x + v) : () => any >() => x + v : () => any >x + v : any ->x : number +>x : 1 >v : any if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -700,19 +700,19 @@ function foo4_c(x) { >x : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 var v = y; >v : number ->y : number +>y : 0 let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + v }); >(function() { return x + v }) : () => number @@ -748,25 +748,25 @@ function foo5_c(x) { >x : any for (const x = 0, y = 1; x < 1;) { ->x : number ->0 : number ->y : number ->1 : number +>x : 0 +>0 : 0 +>y : 1 +>1 : 1 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 var v = x; >v : number ->x : number +>x : 0 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 >v : number (() => x + y + v); @@ -774,13 +774,13 @@ function foo5_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 return; @@ -804,22 +804,22 @@ function foo6_c(x) { >1 : 1 const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number (() => x + y + v); @@ -827,13 +827,13 @@ function foo6_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -852,22 +852,22 @@ function foo7_c(x) { do { const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number (() => x + y + v); @@ -875,13 +875,13 @@ function foo7_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -903,27 +903,27 @@ function foo8_c(x) { >x : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 >v : number (() => x + y + v); @@ -931,13 +931,13 @@ function foo8_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols index 5b40cb44599..7e3d9a07422 100644 --- a/tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols @@ -1,31 +1,30 @@ === tests/cases/compiler/capturedLetConstInLoop5_ES6.ts === - declare function use(a: any); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->a : Symbol(a, Decl(capturedLetConstInLoop5_ES6.ts, 1, 21)) +>a : Symbol(a, Decl(capturedLetConstInLoop5_ES6.ts, 0, 21)) //====let function foo0(x) { ->foo0 : Symbol(foo0, Decl(capturedLetConstInLoop5_ES6.ts, 1, 29)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 4, 14)) +>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop5_ES6.ts, 0, 29)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 3, 14)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 4, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 5, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 4, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 4, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 5, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 4, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 5, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 4, 12)) return; } @@ -33,30 +32,30 @@ function foo0(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 5, 11)) } function foo00(x) { ->foo00 : Symbol(foo00, Decl(capturedLetConstInLoop5_ES6.ts, 15, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 17, 15)) +>foo00 : Symbol(foo00, Decl(capturedLetConstInLoop5_ES6.ts, 14, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 16, 15)) for (let x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 17, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 18, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 17, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 17, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 18, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 17, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 18, 11)) if (x == "1") { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 17, 12)) return; } @@ -64,32 +63,32 @@ function foo00(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 18, 11)) } function foo1(x) { ->foo1 : Symbol(foo1, Decl(capturedLetConstInLoop5_ES6.ts, 28, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 14)) +>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop5_ES6.ts, 27, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 29, 14)) for (let x = 0; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 31, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 12)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 31, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 31, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 12)) return; } @@ -97,31 +96,31 @@ function foo1(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 31, 11)) } function foo2(x) { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop5_ES6.ts, 41, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 43, 14)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop5_ES6.ts, 40, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 42, 14)) while (1 === 1) { let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 44, 11)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 44, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 44, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 44, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 44, 11)) return; } @@ -129,30 +128,30 @@ function foo2(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11)) } function foo3(x) { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop5_ES6.ts, 55, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 57, 14)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop5_ES6.ts, 54, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 56, 14)) do { let x; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 58, 11)) var v; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 58, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 58, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 58, 11)) return; } @@ -160,35 +159,35 @@ function foo3(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11)) } function foo4(x) { ->foo4 : Symbol(foo4, Decl(capturedLetConstInLoop5_ES6.ts, 69, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 71, 14)) +>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop5_ES6.ts, 68, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 70, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 71, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 71, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 71, 12)) var v = y; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 72, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 71, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 72, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 72, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) return; } @@ -196,35 +195,35 @@ function foo4(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 72, 11)) } function foo5(x) { ->foo5 : Symbol(foo5, Decl(capturedLetConstInLoop5_ES6.ts, 83, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 14)) +>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop5_ES6.ts, 82, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 84, 14)) for (let x = 0, y = 1; x < 1; ++x) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 86, 19)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 85, 19)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 12)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 86, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 12)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 86, 19)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 85, 19)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 86, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 86, 19)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 85, 19)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 86, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 12)) return; } @@ -232,35 +231,35 @@ function foo5(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 86, 11)) } function foo6(x) { ->foo6 : Symbol(foo6, Decl(capturedLetConstInLoop5_ES6.ts, 96, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 99, 14)) +>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop5_ES6.ts, 95, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 98, 14)) while (1 === 1) { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 101, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 100, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 100, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 100, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 101, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 100, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 100, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 101, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 100, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 100, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 100, 11)) return; } @@ -268,34 +267,34 @@ function foo6(x) { use(v) >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11)) } function foo7(x) { ->foo7 : Symbol(foo7, Decl(capturedLetConstInLoop5_ES6.ts, 111, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 113, 14)) +>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop5_ES6.ts, 110, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 112, 14)) do { let x, y; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 115, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 114, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 114, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 114, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 115, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 114, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 114, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 115, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 114, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 114, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 114, 11)) return; } @@ -303,38 +302,38 @@ function foo7(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11)) } function foo8(x) { ->foo8 : Symbol(foo8, Decl(capturedLetConstInLoop5_ES6.ts, 125, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 128, 14)) +>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop5_ES6.ts, 124, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 127, 14)) for (let y = 0; y < 1; ++y) { ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 128, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 128, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 128, 12)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 129, 11)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 129, 11)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 129, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 128, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 129, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 128, 12)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 129, 11)) return; } @@ -342,31 +341,31 @@ function foo8(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11)) } //====const function foo0_c(x) { ->foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop5_ES6.ts, 140, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 143, 16)) +>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop5_ES6.ts, 139, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 142, 16)) for (const x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 143, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 144, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 143, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 143, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 144, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 143, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 144, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 143, 14)) return; } @@ -374,30 +373,30 @@ function foo0_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 144, 11)) } function foo00_c(x) { ->foo00_c : Symbol(foo00_c, Decl(capturedLetConstInLoop5_ES6.ts, 154, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 156, 17)) +>foo00_c : Symbol(foo00_c, Decl(capturedLetConstInLoop5_ES6.ts, 153, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 155, 17)) for (const x in []) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 156, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 157, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 156, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 156, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 157, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 156, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 157, 11)) if (x == "1") { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 156, 14)) return; } @@ -405,31 +404,31 @@ function foo00_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 157, 11)) } function foo1_c(x) { ->foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop5_ES6.ts, 167, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 16)) +>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop5_ES6.ts, 166, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 168, 16)) for (const x = 0; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 170, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 14)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 170, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 170, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 14)) return; } @@ -437,31 +436,31 @@ function foo1_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 170, 11)) } function foo2_c(x) { ->foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop5_ES6.ts, 180, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 182, 16)) +>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop5_ES6.ts, 179, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 181, 16)) while (1 === 1) { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 183, 13)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 184, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 183, 13)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 183, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 184, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 183, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 184, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 183, 13)) return; } @@ -469,30 +468,30 @@ function foo2_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 184, 11)) } function foo3_c(x) { ->foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop5_ES6.ts, 194, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 196, 16)) +>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop5_ES6.ts, 193, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 195, 16)) do { const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 197, 13)) var v; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 198, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 197, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 198, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 197, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 198, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 197, 13)) return; } @@ -500,34 +499,34 @@ function foo3_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 198, 11)) } function foo4_c(x) { ->foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop5_ES6.ts, 208, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 210, 16)) +>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop5_ES6.ts, 207, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 209, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 211, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 211, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 210, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 210, 14)) var v = y; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 211, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 211, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 210, 14)) let x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) (function() { return x + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 211, 11)) (() => x + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 211, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) return; } @@ -535,34 +534,34 @@ function foo4_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 211, 11)) } function foo5_c(x) { ->foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop5_ES6.ts, 222, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 16)) +>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop5_ES6.ts, 221, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 223, 16)) for (const x = 0, y = 1; x < 1;) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 225, 21)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 224, 21)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 14)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 225, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 14)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 225, 21)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 224, 21)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 225, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 225, 21)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 224, 21)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 225, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 14)) return; } @@ -570,35 +569,35 @@ function foo5_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 225, 11)) } function foo6_c(x) { ->foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop5_ES6.ts, 235, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 238, 16)) +>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop5_ES6.ts, 234, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 237, 16)) while (1 === 1) { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 240, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 239, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 239, 20)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 240, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 239, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 240, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 239, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 239, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 240, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 240, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 239, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 239, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 240, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 239, 13)) return; } @@ -606,34 +605,34 @@ function foo6_c(x) { use(v) >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 240, 11)) } function foo7_c(x) { ->foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop5_ES6.ts, 250, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 252, 16)) +>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop5_ES6.ts, 249, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 251, 16)) do { const x = 1, y = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 254, 20)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 253, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 253, 20)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 254, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 253, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 254, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 253, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 253, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 254, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 254, 20)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 253, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 253, 20)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 254, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 253, 13)) return; } @@ -641,37 +640,37 @@ function foo7_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 254, 11)) } function foo8_c(x) { ->foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop5_ES6.ts, 264, 1)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 267, 16)) +>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop5_ES6.ts, 263, 1)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 266, 16)) for (const y = 0; y < 1;) { ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 267, 14)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 267, 14)) const x = 1; ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 268, 13)) var v = x; ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11)) ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 269, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 268, 13)) (function() { return x + y + v }); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 268, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 267, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 269, 11)) (() => x + y + v); ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13)) ->y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 268, 13)) +>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 267, 14)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 269, 11)) if (x == 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13)) +>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 268, 13)) return; } @@ -679,5 +678,5 @@ function foo8_c(x) { use(v); >use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0)) ->v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11)) +>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 269, 11)) } diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.types b/tests/baselines/reference/capturedLetConstInLoop5_ES6.types index 78b41d7cdf3..0a59687ebb3 100644 --- a/tests/baselines/reference/capturedLetConstInLoop5_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.types @@ -1,5 +1,4 @@ === tests/cases/compiler/capturedLetConstInLoop5_ES6.ts === - declare function use(a: any); >use : (a: any) => any >a : any @@ -93,10 +92,10 @@ function foo1(x) { for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -144,7 +143,7 @@ function foo2(x) { let x = 1; >x : number ->1 : number +>1 : 1 var v = x; >v : number @@ -228,10 +227,10 @@ function foo4(x) { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number @@ -241,7 +240,7 @@ function foo4(x) { let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + v }); >(function() { return x + v }) : () => number @@ -278,12 +277,12 @@ function foo5(x) { for (let x = 0, y = 1; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >y : number ->1 : number +>1 : 1 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -431,16 +430,16 @@ function foo8(x) { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 var v = x; >v : number @@ -567,33 +566,33 @@ function foo1_c(x) { >x : any for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 var v = x; >v : number ->x : number +>x : 0 (function() { return x + v }); >(function() { return x + v }) : () => number >function() { return x + v } : () => number >x + v : number ->x : number +>x : 0 >v : number (() => x + v); >(() => x + v) : () => number >() => x + v : () => number >x + v : number ->x : number +>x : 0 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 return; @@ -616,30 +615,30 @@ function foo2_c(x) { >1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + v }); >(function() { return x + v }) : () => number >function() { return x + v } : () => number >x + v : number ->x : number +>x : 1 >v : number (() => x + v); >(() => x + v) : () => number >() => x + v : () => number >x + v : number ->x : number +>x : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -658,8 +657,8 @@ function foo3_c(x) { do { const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 var v; >v : any @@ -668,19 +667,19 @@ function foo3_c(x) { >(function() { return x + v }) : () => any >function() { return x + v } : () => any >x + v : any ->x : number +>x : 1 >v : any (() => x + v); >(() => x + v) : () => any >() => x + v : () => any >x + v : any ->x : number +>x : 1 >v : any if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -701,19 +700,19 @@ function foo4_c(x) { >x : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 var v = y; >v : number ->y : number +>y : 0 let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + v }); >(function() { return x + v }) : () => number @@ -749,25 +748,25 @@ function foo5_c(x) { >x : any for (const x = 0, y = 1; x < 1;) { ->x : number ->0 : number ->y : number ->1 : number +>x : 0 +>0 : 0 +>y : 1 +>1 : 1 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 var v = x; >v : number ->x : number +>x : 0 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 >v : number (() => x + y + v); @@ -775,13 +774,13 @@ function foo5_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 return; @@ -805,22 +804,22 @@ function foo6_c(x) { >1 : 1 const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number (() => x + y + v); @@ -828,13 +827,13 @@ function foo6_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -853,22 +852,22 @@ function foo7_c(x) { do { const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number (() => x + y + v); @@ -876,13 +875,13 @@ function foo7_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; @@ -904,27 +903,27 @@ function foo8_c(x) { >x : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 var v = x; >v : number ->x : number +>x : 1 (function() { return x + y + v }); >(function() { return x + y + v }) : () => number >function() { return x + y + v } : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 >v : number (() => x + y + v); @@ -932,13 +931,13 @@ function foo8_c(x) { >() => x + y + v : () => number >x + y + v : number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 >v : number if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 return; diff --git a/tests/baselines/reference/capturedLetConstInLoop6.types b/tests/baselines/reference/capturedLetConstInLoop6.types index a7d28222bb0..c7f6392139e 100644 --- a/tests/baselines/reference/capturedLetConstInLoop6.types +++ b/tests/baselines/reference/capturedLetConstInLoop6.types @@ -63,10 +63,10 @@ for (let x in []) { for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -165,16 +165,16 @@ do { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x}); >(function() { return x}) : () => number @@ -204,12 +204,12 @@ for (let y = 0; y < 1; ++y) { for (let x = 0, y = 1; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >y : number ->1 : number +>1 : 1 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -322,16 +322,16 @@ do { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number @@ -427,32 +427,32 @@ for (const x in []) { for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 0 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; @@ -465,29 +465,29 @@ while (1 === 1) { >1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -496,29 +496,29 @@ while (1 === 1) { do { const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -529,36 +529,36 @@ do { >1 : 1 for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -566,38 +566,38 @@ for (const y = 0; y < 1;) { } for (const x = 0, y = 1; x < 1;) { ->x : number ->0 : number ->y : number ->1 : number +>x : 0 +>0 : 0 +>y : 1 +>1 : 1 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; @@ -610,35 +610,35 @@ while (1 === 1) { >1 : 1 const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -647,35 +647,35 @@ while (1 === 1) { do { const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -686,40 +686,40 @@ do { >1 : 1 for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; diff --git a/tests/baselines/reference/capturedLetConstInLoop6_ES6.types b/tests/baselines/reference/capturedLetConstInLoop6_ES6.types index 14635c0cd1c..79da473e934 100644 --- a/tests/baselines/reference/capturedLetConstInLoop6_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop6_ES6.types @@ -63,10 +63,10 @@ for (let x in []) { for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -165,16 +165,16 @@ do { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x}); >(function() { return x}) : () => number @@ -204,12 +204,12 @@ for (let y = 0; y < 1; ++y) { for (let x = 0, y = 1; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >y : number ->1 : number +>1 : 1 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -322,16 +322,16 @@ do { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number @@ -427,32 +427,32 @@ for (const x in []) { for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 0 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; @@ -465,29 +465,29 @@ while (1 === 1) { >1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -496,29 +496,29 @@ while (1 === 1) { do { const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -529,36 +529,36 @@ do { >1 : 1 for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -566,38 +566,38 @@ for (const y = 0; y < 1;) { } for (const x = 0, y = 1; x < 1;) { ->x : number ->0 : number ->y : number ->1 : number +>x : 0 +>0 : 0 +>y : 1 +>1 : 1 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; @@ -610,35 +610,35 @@ while (1 === 1) { >1 : 1 const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -647,35 +647,35 @@ while (1 === 1) { do { const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; @@ -686,40 +686,40 @@ do { >1 : 1 for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; diff --git a/tests/baselines/reference/capturedLetConstInLoop7.types b/tests/baselines/reference/capturedLetConstInLoop7.types index 641ccb9dbea..39f09100eeb 100644 --- a/tests/baselines/reference/capturedLetConstInLoop7.types +++ b/tests/baselines/reference/capturedLetConstInLoop7.types @@ -103,10 +103,10 @@ l1: for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -262,16 +262,16 @@ l4: for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x}); >(function() { return x}) : () => number @@ -320,12 +320,12 @@ l5: for (let x = 0, y = 1; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >y : number ->1 : number +>1 : 1 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -496,16 +496,16 @@ l8: for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number @@ -656,32 +656,32 @@ l1_c: >l1_c : any for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 0 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break l1_c; @@ -689,14 +689,14 @@ for (const x = 0; x < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l1_c; @@ -713,29 +713,29 @@ while (1 === 1) { >1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l2_c; @@ -743,14 +743,14 @@ while (1 === 1) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l2_c; @@ -763,29 +763,29 @@ l3_c: do { const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l3_c; @@ -793,14 +793,14 @@ do { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l3_c; @@ -815,36 +815,36 @@ l4_c: >l4_c : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l4_c; @@ -852,14 +852,14 @@ for (const y = 0; y < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l4_c; @@ -871,38 +871,38 @@ l5_c: >l5_c : any for (const x = 0, y = 1; x < 1;) { ->x : number ->0 : number ->y : number ->1 : number +>x : 0 +>0 : 0 +>y : 1 +>1 : 1 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break l5_c; @@ -910,14 +910,14 @@ for (const x = 0, y = 1; x < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l5_c; @@ -934,35 +934,35 @@ while (1 === 1) { >1 : 1 const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l6_c; @@ -970,14 +970,14 @@ while (1 === 1) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l6_c; @@ -991,35 +991,35 @@ l7_c: do { const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l7_c; @@ -1027,14 +1027,14 @@ do { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l7_c; @@ -1049,40 +1049,40 @@ l8_c: >l8_c : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l8_c; @@ -1090,14 +1090,14 @@ for (const y = 0; y < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l8_c; diff --git a/tests/baselines/reference/capturedLetConstInLoop7_ES6.types b/tests/baselines/reference/capturedLetConstInLoop7_ES6.types index 666f3e33e0f..48499659aa3 100644 --- a/tests/baselines/reference/capturedLetConstInLoop7_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop7_ES6.types @@ -103,10 +103,10 @@ l1: for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -262,16 +262,16 @@ l4: for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x}); >(function() { return x}) : () => number @@ -320,12 +320,12 @@ l5: for (let x = 0, y = 1; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >y : number ->1 : number +>1 : 1 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -496,16 +496,16 @@ l8: for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number let x = 1; >x : number ->1 : number +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number @@ -656,32 +656,32 @@ l1_c: >l1_c : any for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 0 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break l1_c; @@ -689,14 +689,14 @@ for (const x = 0; x < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l1_c; @@ -713,29 +713,29 @@ while (1 === 1) { >1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l2_c; @@ -743,14 +743,14 @@ while (1 === 1) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l2_c; @@ -763,29 +763,29 @@ l3_c: do { const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l3_c; @@ -793,14 +793,14 @@ do { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l3_c; @@ -815,36 +815,36 @@ l4_c: >l4_c : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x}); >(function() { return x}) : () => number >function() { return x} : () => number ->x : number +>x : 1 (() => x); >(() => x) : () => number >() => x : () => number ->x : number +>x : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l4_c; @@ -852,14 +852,14 @@ for (const y = 0; y < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l4_c; @@ -871,38 +871,38 @@ l5_c: >l5_c : any for (const x = 0, y = 1; x < 1;) { ->x : number ->0 : number ->y : number ->1 : number +>x : 0 +>0 : 0 +>y : 1 +>1 : 1 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break l5_c; @@ -910,14 +910,14 @@ for (const x = 0, y = 1; x < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l5_c; @@ -934,35 +934,35 @@ while (1 === 1) { >1 : 1 const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l6_c; @@ -970,14 +970,14 @@ while (1 === 1) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l6_c; @@ -991,35 +991,35 @@ l7_c: do { const x = 1, y = 1; ->x : number ->1 : number ->y : number ->1 : number +>x : 1 +>1 : 1 +>y : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 1 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l7_c; @@ -1027,14 +1027,14 @@ do { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l7_c; @@ -1049,40 +1049,40 @@ l8_c: >l8_c : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 const x = 1; ->x : number ->1 : number +>x : 1 +>1 : 1 (function() { return x + y}); >(function() { return x + y}) : () => number >function() { return x + y} : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 1 +>y : 0 if (x == 1) { >x == 1 : boolean ->x : number +>x : 1 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : never >1 : 1 break l8_c; @@ -1090,14 +1090,14 @@ for (const y = 0; y < 1;) { } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : never >2 : 2 continue l8_c; diff --git a/tests/baselines/reference/capturedLetConstInLoop8.types b/tests/baselines/reference/capturedLetConstInLoop8.types index 618e71038ff..26473308039 100644 --- a/tests/baselines/reference/capturedLetConstInLoop8.types +++ b/tests/baselines/reference/capturedLetConstInLoop8.types @@ -1,16 +1,16 @@ === tests/cases/compiler/capturedLetConstInLoop8.ts === function foo() { ->foo : () => string +>foo : () => "123" | "456" l0: >l0 : any for (let z = 0; z < 1; ++z) { >z : number ->0 : number +>0 : 0 >z < 1 : boolean >z : number ->1 : number +>1 : 1 >++z : number >z : number @@ -19,10 +19,10 @@ function foo() { for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -31,10 +31,10 @@ function foo() { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number @@ -113,7 +113,7 @@ function foo() { >2 : 2 return "123" ->"123" : string +>"123" : "123" } if (x == 3) { >x == 3 : boolean @@ -167,7 +167,7 @@ function foo() { >2 : 2 return "456"; ->"456" : string +>"456" : "456" } if (x == 3) { >x == 3 : boolean @@ -181,62 +181,62 @@ function foo() { } function foo_c() { ->foo_c : () => string +>foo_c : () => "123" | "456" l0: >l0 : any for (const z = 0; z < 1;) { ->z : number ->0 : number +>z : 0 +>0 : 0 >z < 1 : boolean ->z : number ->1 : number +>z : 0 +>1 : 1 l1: >l1 : any for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 ll1: >ll1 : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 (function() { return x + y }); >(function() { return x + y }) : () => number >function() { return x + y } : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 0 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 0 if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 break; } if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 break l1; @@ -244,7 +244,7 @@ function foo_c() { } if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 break ll1; @@ -252,7 +252,7 @@ function foo_c() { } if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 continue l0; @@ -261,14 +261,14 @@ function foo_c() { if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l1; @@ -276,7 +276,7 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue ll1; @@ -284,15 +284,15 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 return "123" ->"123" : string +>"123" : "123" } if (x == 3) { >x == 3 : boolean ->x : number +>x : 0 >3 : 3 return; @@ -300,14 +300,14 @@ function foo_c() { } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break l1; @@ -315,14 +315,14 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l1; @@ -330,7 +330,7 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l0; @@ -338,15 +338,15 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 return "456"; ->"456" : string +>"456" : "456" } if (x == 3) { >x == 3 : boolean ->x : number +>x : 0 >3 : 3 return; diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.types b/tests/baselines/reference/capturedLetConstInLoop8_ES6.types index 0b877d27a46..99d07bb99bf 100644 --- a/tests/baselines/reference/capturedLetConstInLoop8_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.types @@ -1,16 +1,16 @@ === tests/cases/compiler/capturedLetConstInLoop8_ES6.ts === function foo() { ->foo : () => string +>foo : () => "123" | "456" l0: >l0 : any for (let z = 0; z < 1; ++z) { >z : number ->0 : number +>0 : 0 >z < 1 : boolean >z : number ->1 : number +>1 : 1 >++z : number >z : number @@ -19,10 +19,10 @@ function foo() { for (let x = 0; x < 1; ++x) { >x : number ->0 : number +>0 : 0 >x < 1 : boolean >x : number ->1 : number +>1 : 1 >++x : number >x : number @@ -31,10 +31,10 @@ function foo() { for (let y = 0; y < 1; ++y) { >y : number ->0 : number +>0 : 0 >y < 1 : boolean >y : number ->1 : number +>1 : 1 >++y : number >y : number @@ -113,7 +113,7 @@ function foo() { >2 : 2 return "123" ->"123" : string +>"123" : "123" } if (x == 3) { >x == 3 : boolean @@ -167,7 +167,7 @@ function foo() { >2 : 2 return "456"; ->"456" : string +>"456" : "456" } if (x == 3) { >x == 3 : boolean @@ -181,62 +181,62 @@ function foo() { } function foo_c() { ->foo_c : () => string +>foo_c : () => "123" | "456" l0: >l0 : any for (const z = 0; z < 1;) { ->z : number ->0 : number +>z : 0 +>0 : 0 >z < 1 : boolean ->z : number ->1 : number +>z : 0 +>1 : 1 l1: >l1 : any for (const x = 0; x < 1;) { ->x : number ->0 : number +>x : 0 +>0 : 0 >x < 1 : boolean ->x : number ->1 : number +>x : 0 +>1 : 1 ll1: >ll1 : any for (const y = 0; y < 1;) { ->y : number ->0 : number +>y : 0 +>0 : 0 >y < 1 : boolean ->y : number ->1 : number +>y : 0 +>1 : 1 (function() { return x + y }); >(function() { return x + y }) : () => number >function() { return x + y } : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 0 (() => x + y); >(() => x + y) : () => number >() => x + y : () => number >x + y : number ->x : number ->y : number +>x : 0 +>y : 0 if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 break; } if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 break l1; @@ -244,7 +244,7 @@ function foo_c() { } if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 break ll1; @@ -252,7 +252,7 @@ function foo_c() { } if (y == 1) { >y == 1 : boolean ->y : number +>y : 0 >1 : 1 continue l0; @@ -261,14 +261,14 @@ function foo_c() { if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l1; @@ -276,7 +276,7 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue ll1; @@ -284,15 +284,15 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 return "123" ->"123" : string +>"123" : "123" } if (x == 3) { >x == 3 : boolean ->x : number +>x : 0 >3 : 3 return; @@ -300,14 +300,14 @@ function foo_c() { } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break; } if (x == 1) { >x == 1 : boolean ->x : number +>x : 0 >1 : 1 break l1; @@ -315,14 +315,14 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue; } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l1; @@ -330,7 +330,7 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 continue l0; @@ -338,15 +338,15 @@ function foo_c() { } if (x == 2) { >x == 2 : boolean ->x : number +>x : 0 >2 : 2 return "456"; ->"456" : string +>"456" : "456" } if (x == 3) { >x == 3 : boolean ->x : number +>x : 0 >3 : 3 return; diff --git a/tests/baselines/reference/capturedParametersInInitializers2.symbols b/tests/baselines/reference/capturedParametersInInitializers2.symbols new file mode 100644 index 00000000000..eb87347275f --- /dev/null +++ b/tests/baselines/reference/capturedParametersInInitializers2.symbols @@ -0,0 +1,20 @@ +=== tests/cases/compiler/capturedParametersInInitializers2.ts === +function foo(y = class {static c = x}, x = 1) { +>foo : Symbol(foo, Decl(capturedParametersInInitializers2.ts, 0, 0)) +>y : Symbol(y, Decl(capturedParametersInInitializers2.ts, 0, 13)) +>c : Symbol((Anonymous class).c, Decl(capturedParametersInInitializers2.ts, 0, 24)) +>x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 0, 38)) +>x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 0, 38)) + + y.c +>y.c : Symbol((Anonymous class).c, Decl(capturedParametersInInitializers2.ts, 0, 24)) +>y : Symbol(y, Decl(capturedParametersInInitializers2.ts, 0, 13)) +>c : Symbol((Anonymous class).c, Decl(capturedParametersInInitializers2.ts, 0, 24)) +} +function foo2(y = class {[x] = x}, x = 1) { +>foo2 : Symbol(foo2, Decl(capturedParametersInInitializers2.ts, 2, 1)) +>y : Symbol(y, Decl(capturedParametersInInitializers2.ts, 3, 14)) +>x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 3, 34)) +>x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 3, 34)) +>x : Symbol(x, Decl(capturedParametersInInitializers2.ts, 3, 34)) +} diff --git a/tests/baselines/reference/capturedParametersInInitializers2.types b/tests/baselines/reference/capturedParametersInInitializers2.types new file mode 100644 index 00000000000..d10d3f2b215 --- /dev/null +++ b/tests/baselines/reference/capturedParametersInInitializers2.types @@ -0,0 +1,24 @@ +=== tests/cases/compiler/capturedParametersInInitializers2.ts === +function foo(y = class {static c = x}, x = 1) { +>foo : (y?: typeof (Anonymous class), x?: number) => void +>y : typeof (Anonymous class) +>class {static c = x} : typeof (Anonymous class) +>c : number +>x : number +>x : number +>1 : 1 + + y.c +>y.c : number +>y : typeof (Anonymous class) +>c : number +} +function foo2(y = class {[x] = x}, x = 1) { +>foo2 : (y?: typeof (Anonymous class), x?: number) => void +>y : typeof (Anonymous class) +>class {[x] = x} : typeof (Anonymous class) +>x : number +>x : number +>x : number +>1 : 1 +} diff --git a/tests/baselines/reference/castOfYield.symbols b/tests/baselines/reference/castOfYield.symbols new file mode 100644 index 00000000000..b4b495a0a36 --- /dev/null +++ b/tests/baselines/reference/castOfYield.symbols @@ -0,0 +1,9 @@ +=== tests/cases/compiler/castOfYield.ts === +function* f() { +>f : Symbol(f, Decl(castOfYield.ts, 0, 0)) + + (yield 0); + // Unlike await, yield is not allowed to appear in a simple unary expression. + yield 0; +} + diff --git a/tests/baselines/reference/castOfYield.types b/tests/baselines/reference/castOfYield.types new file mode 100644 index 00000000000..c0052056091 --- /dev/null +++ b/tests/baselines/reference/castOfYield.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/castOfYield.ts === +function* f() { +>f : () => {} + + (yield 0); +> (yield 0) : number +>(yield 0) : any +>yield 0 : any +>0 : 0 + + // Unlike await, yield is not allowed to appear in a simple unary expression. + yield 0; +> : number +> : any +>yield 0 : any +>0 : 0 +} + diff --git a/tests/baselines/reference/castParentheses.symbols b/tests/baselines/reference/castParentheses.symbols index 6447c8721e2..0ef44823f2d 100644 --- a/tests/baselines/reference/castParentheses.symbols +++ b/tests/baselines/reference/castParentheses.symbols @@ -7,36 +7,36 @@ class a { } var b = (a); ->b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3), Decl(castParentheses.ts, 9, 3), Decl(castParentheses.ts, 10, 3)) +>b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3) ... and 2 more) >a : Symbol(a, Decl(castParentheses.ts, 0, 0)) var b = (a).b; ->b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3), Decl(castParentheses.ts, 9, 3), Decl(castParentheses.ts, 10, 3)) +>b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3) ... and 2 more) >a : Symbol(a, Decl(castParentheses.ts, 0, 0)) var b = (a.b).c; ->b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3), Decl(castParentheses.ts, 9, 3), Decl(castParentheses.ts, 10, 3)) +>b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3) ... and 2 more) >a.b : Symbol(a.b, Decl(castParentheses.ts, 0, 9)) >a : Symbol(a, Decl(castParentheses.ts, 0, 0)) >b : Symbol(a.b, Decl(castParentheses.ts, 0, 9)) var b = (a.b()).c; ->b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3), Decl(castParentheses.ts, 9, 3), Decl(castParentheses.ts, 10, 3)) +>b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3) ... and 2 more) >a.b : Symbol(a.b, Decl(castParentheses.ts, 0, 9)) >a : Symbol(a, Decl(castParentheses.ts, 0, 0)) >b : Symbol(a.b, Decl(castParentheses.ts, 0, 9)) var b = (new a); ->b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3), Decl(castParentheses.ts, 9, 3), Decl(castParentheses.ts, 10, 3)) +>b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3) ... and 2 more) >a : Symbol(a, Decl(castParentheses.ts, 0, 0)) var b = (new a.b); ->b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3), Decl(castParentheses.ts, 9, 3), Decl(castParentheses.ts, 10, 3)) +>b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3) ... and 2 more) >a.b : Symbol(a.b, Decl(castParentheses.ts, 0, 9)) >a : Symbol(a, Decl(castParentheses.ts, 0, 0)) >b : Symbol(a.b, Decl(castParentheses.ts, 0, 9)) var b = (new a).b ->b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3), Decl(castParentheses.ts, 9, 3), Decl(castParentheses.ts, 10, 3)) +>b : Symbol(b, Decl(castParentheses.ts, 4, 3), Decl(castParentheses.ts, 5, 3), Decl(castParentheses.ts, 6, 3), Decl(castParentheses.ts, 7, 3), Decl(castParentheses.ts, 8, 3) ... and 2 more) >a : Symbol(a, Decl(castParentheses.ts, 0, 0)) diff --git a/tests/baselines/reference/castingTuple.symbols b/tests/baselines/reference/castingTuple.symbols new file mode 100644 index 00000000000..61edfb4b376 --- /dev/null +++ b/tests/baselines/reference/castingTuple.symbols @@ -0,0 +1,132 @@ +=== tests/cases/conformance/types/tuple/castingTuple.ts === +interface I { } +>I : Symbol(I, Decl(castingTuple.ts, 0, 0)) + +class A { a = 10; } +>A : Symbol(A, Decl(castingTuple.ts, 0, 15)) +>a : Symbol(A.a, Decl(castingTuple.ts, 1, 9)) + +class C implements I { c }; +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) +>I : Symbol(I, Decl(castingTuple.ts, 0, 0)) +>c : Symbol(C.c, Decl(castingTuple.ts, 2, 22)) + +class D implements I { d }; +>D : Symbol(D, Decl(castingTuple.ts, 2, 27)) +>I : Symbol(I, Decl(castingTuple.ts, 0, 0)) +>d : Symbol(D.d, Decl(castingTuple.ts, 3, 22)) + +class E extends A { e }; +>E : Symbol(E, Decl(castingTuple.ts, 3, 27)) +>A : Symbol(A, Decl(castingTuple.ts, 0, 15)) +>e : Symbol(E.e, Decl(castingTuple.ts, 4, 19)) + +class F extends A { f }; +>F : Symbol(F, Decl(castingTuple.ts, 4, 24)) +>A : Symbol(A, Decl(castingTuple.ts, 0, 15)) +>f : Symbol(F.f, Decl(castingTuple.ts, 5, 19)) + +enum E1 { one } +>E1 : Symbol(E1, Decl(castingTuple.ts, 5, 24)) +>one : Symbol(E1.one, Decl(castingTuple.ts, 6, 9)) + +enum E2 { one } +>E2 : Symbol(E2, Decl(castingTuple.ts, 6, 15)) +>one : Symbol(E2.one, Decl(castingTuple.ts, 7, 9)) + +// no error +var numStrTuple: [number, string] = [5, "foo"]; +>numStrTuple : Symbol(numStrTuple, Decl(castingTuple.ts, 10, 3)) + +var emptyObjTuple = <[{}, {}]>numStrTuple; +>emptyObjTuple : Symbol(emptyObjTuple, Decl(castingTuple.ts, 11, 3)) +>numStrTuple : Symbol(numStrTuple, Decl(castingTuple.ts, 10, 3)) + +var numStrBoolTuple = <[number, string, boolean]>numStrTuple; +>numStrBoolTuple : Symbol(numStrBoolTuple, Decl(castingTuple.ts, 12, 3)) +>numStrTuple : Symbol(numStrTuple, Decl(castingTuple.ts, 10, 3)) + +var classCDTuple: [C, D] = [new C(), new D()]; +>classCDTuple : Symbol(classCDTuple, Decl(castingTuple.ts, 13, 3)) +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) +>D : Symbol(D, Decl(castingTuple.ts, 2, 27)) +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) +>D : Symbol(D, Decl(castingTuple.ts, 2, 27)) + +var interfaceIITuple = <[I, I]>classCDTuple; +>interfaceIITuple : Symbol(interfaceIITuple, Decl(castingTuple.ts, 14, 3)) +>I : Symbol(I, Decl(castingTuple.ts, 0, 0)) +>I : Symbol(I, Decl(castingTuple.ts, 0, 0)) +>classCDTuple : Symbol(classCDTuple, Decl(castingTuple.ts, 13, 3)) + +var classCDATuple = <[C, D, A]>classCDTuple; +>classCDATuple : Symbol(classCDATuple, Decl(castingTuple.ts, 15, 3)) +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) +>D : Symbol(D, Decl(castingTuple.ts, 2, 27)) +>A : Symbol(A, Decl(castingTuple.ts, 0, 15)) +>classCDTuple : Symbol(classCDTuple, Decl(castingTuple.ts, 13, 3)) + +var eleFromCDA1 = classCDATuple[2]; // A +>eleFromCDA1 : Symbol(eleFromCDA1, Decl(castingTuple.ts, 16, 3)) +>classCDATuple : Symbol(classCDATuple, Decl(castingTuple.ts, 15, 3)) +>2 : Symbol(2) + +var eleFromCDA2 = classCDATuple[5]; // C | D | A +>eleFromCDA2 : Symbol(eleFromCDA2, Decl(castingTuple.ts, 17, 3)) +>classCDATuple : Symbol(classCDATuple, Decl(castingTuple.ts, 15, 3)) + +var t10: [E1, E2] = [E1.one, E2.one]; +>t10 : Symbol(t10, Decl(castingTuple.ts, 18, 3)) +>E1 : Symbol(E1, Decl(castingTuple.ts, 5, 24)) +>E2 : Symbol(E2, Decl(castingTuple.ts, 6, 15)) +>E1.one : Symbol(E1.one, Decl(castingTuple.ts, 6, 9)) +>E1 : Symbol(E1, Decl(castingTuple.ts, 5, 24)) +>one : Symbol(E1.one, Decl(castingTuple.ts, 6, 9)) +>E2.one : Symbol(E2.one, Decl(castingTuple.ts, 7, 9)) +>E2 : Symbol(E2, Decl(castingTuple.ts, 6, 15)) +>one : Symbol(E2.one, Decl(castingTuple.ts, 7, 9)) + +var t11 = <[number, number]>t10; +>t11 : Symbol(t11, Decl(castingTuple.ts, 19, 3)) +>t10 : Symbol(t10, Decl(castingTuple.ts, 18, 3)) + +var array1 = <{}[]>emptyObjTuple; +>array1 : Symbol(array1, Decl(castingTuple.ts, 20, 3), Decl(castingTuple.ts, 29, 3)) +>emptyObjTuple : Symbol(emptyObjTuple, Decl(castingTuple.ts, 11, 3)) + +var unionTuple: [C, string | number] = [new C(), "foo"]; +>unionTuple : Symbol(unionTuple, Decl(castingTuple.ts, 21, 3)) +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) + +var unionTuple2: [C, string | number, D] = [new C(), "foo", new D()]; +>unionTuple2 : Symbol(unionTuple2, Decl(castingTuple.ts, 22, 3)) +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) +>D : Symbol(D, Decl(castingTuple.ts, 2, 27)) +>C : Symbol(C, Decl(castingTuple.ts, 1, 19)) +>D : Symbol(D, Decl(castingTuple.ts, 2, 27)) + +var unionTuple3: [number, string| number] = [10, "foo"]; +>unionTuple3 : Symbol(unionTuple3, Decl(castingTuple.ts, 23, 3)) + +var unionTuple4 = <[number, number]>unionTuple3; +>unionTuple4 : Symbol(unionTuple4, Decl(castingTuple.ts, 24, 3)) +>unionTuple3 : Symbol(unionTuple3, Decl(castingTuple.ts, 23, 3)) + +// error +var t3 = <[number, number]>numStrTuple; +>t3 : Symbol(t3, Decl(castingTuple.ts, 27, 3)) +>numStrTuple : Symbol(numStrTuple, Decl(castingTuple.ts, 10, 3)) + +var t9 = <[A, I]>classCDTuple; +>t9 : Symbol(t9, Decl(castingTuple.ts, 28, 3)) +>A : Symbol(A, Decl(castingTuple.ts, 0, 15)) +>I : Symbol(I, Decl(castingTuple.ts, 0, 0)) +>classCDTuple : Symbol(classCDTuple, Decl(castingTuple.ts, 13, 3)) + +var array1 = numStrTuple; +>array1 : Symbol(array1, Decl(castingTuple.ts, 20, 3), Decl(castingTuple.ts, 29, 3)) +>numStrTuple : Symbol(numStrTuple, Decl(castingTuple.ts, 10, 3)) + +t4[2] = 10; + diff --git a/tests/baselines/reference/castingTuple.types b/tests/baselines/reference/castingTuple.types new file mode 100644 index 00000000000..23d2e51a576 --- /dev/null +++ b/tests/baselines/reference/castingTuple.types @@ -0,0 +1,168 @@ +=== tests/cases/conformance/types/tuple/castingTuple.ts === +interface I { } +>I : I + +class A { a = 10; } +>A : A +>a : number +>10 : 10 + +class C implements I { c }; +>C : C +>I : I +>c : any + +class D implements I { d }; +>D : D +>I : I +>d : any + +class E extends A { e }; +>E : E +>A : A +>e : any + +class F extends A { f }; +>F : F +>A : A +>f : any + +enum E1 { one } +>E1 : E1 +>one : E1 + +enum E2 { one } +>E2 : E2 +>one : E2 + +// no error +var numStrTuple: [number, string] = [5, "foo"]; +>numStrTuple : [number, string] +>[5, "foo"] : [number, string] +>5 : 5 +>"foo" : "foo" + +var emptyObjTuple = <[{}, {}]>numStrTuple; +>emptyObjTuple : [{}, {}] +><[{}, {}]>numStrTuple : [{}, {}] +>numStrTuple : [number, string] + +var numStrBoolTuple = <[number, string, boolean]>numStrTuple; +>numStrBoolTuple : [number, string, boolean] +><[number, string, boolean]>numStrTuple : [number, string, boolean] +>numStrTuple : [number, string] + +var classCDTuple: [C, D] = [new C(), new D()]; +>classCDTuple : [C, D] +>C : C +>D : D +>[new C(), new D()] : [C, D] +>new C() : C +>C : typeof C +>new D() : D +>D : typeof D + +var interfaceIITuple = <[I, I]>classCDTuple; +>interfaceIITuple : [I, I] +><[I, I]>classCDTuple : [I, I] +>I : I +>I : I +>classCDTuple : [C, D] + +var classCDATuple = <[C, D, A]>classCDTuple; +>classCDATuple : [C, D, A] +><[C, D, A]>classCDTuple : [C, D, A] +>C : C +>D : D +>A : A +>classCDTuple : [C, D] + +var eleFromCDA1 = classCDATuple[2]; // A +>eleFromCDA1 : A +>classCDATuple[2] : A +>classCDATuple : [C, D, A] +>2 : 2 + +var eleFromCDA2 = classCDATuple[5]; // C | D | A +>eleFromCDA2 : A | C | D +>classCDATuple[5] : A | C | D +>classCDATuple : [C, D, A] +>5 : 5 + +var t10: [E1, E2] = [E1.one, E2.one]; +>t10 : [E1, E2] +>E1 : E1 +>E2 : E2 +>[E1.one, E2.one] : [E1, E2] +>E1.one : E1 +>E1 : typeof E1 +>one : E1 +>E2.one : E2 +>E2 : typeof E2 +>one : E2 + +var t11 = <[number, number]>t10; +>t11 : [number, number] +><[number, number]>t10 : [number, number] +>t10 : [E1, E2] + +var array1 = <{}[]>emptyObjTuple; +>array1 : {}[] +><{}[]>emptyObjTuple : {}[] +>emptyObjTuple : [{}, {}] + +var unionTuple: [C, string | number] = [new C(), "foo"]; +>unionTuple : [C, string | number] +>C : C +>[new C(), "foo"] : [C, string] +>new C() : C +>C : typeof C +>"foo" : "foo" + +var unionTuple2: [C, string | number, D] = [new C(), "foo", new D()]; +>unionTuple2 : [C, string | number, D] +>C : C +>D : D +>[new C(), "foo", new D()] : [C, string, D] +>new C() : C +>C : typeof C +>"foo" : "foo" +>new D() : D +>D : typeof D + +var unionTuple3: [number, string| number] = [10, "foo"]; +>unionTuple3 : [number, string | number] +>[10, "foo"] : [number, string] +>10 : 10 +>"foo" : "foo" + +var unionTuple4 = <[number, number]>unionTuple3; +>unionTuple4 : [number, number] +><[number, number]>unionTuple3 : [number, number] +>unionTuple3 : [number, string | number] + +// error +var t3 = <[number, number]>numStrTuple; +>t3 : [number, number] +><[number, number]>numStrTuple : [number, number] +>numStrTuple : [number, string] + +var t9 = <[A, I]>classCDTuple; +>t9 : [A, I] +><[A, I]>classCDTuple : [A, I] +>A : A +>I : I +>classCDTuple : [C, D] + +var array1 = numStrTuple; +>array1 : {}[] +>numStrTuple : number[] +>numStrTuple : [number, string] + +t4[2] = 10; +>t4[2] = 10 : 10 +>t4[2] : any +>t4 : any +>2 : 2 +>10 : 10 + diff --git a/tests/baselines/reference/catchClauseWithInitializer1.symbols b/tests/baselines/reference/catchClauseWithInitializer1.symbols new file mode 100644 index 00000000000..6f39eb6b244 --- /dev/null +++ b/tests/baselines/reference/catchClauseWithInitializer1.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/catchClauseWithInitializer1.ts === +try { +} +catch (e = 1) { +>e : Symbol(e, Decl(catchClauseWithInitializer1.ts, 2, 7)) +} diff --git a/tests/baselines/reference/catchClauseWithInitializer1.types b/tests/baselines/reference/catchClauseWithInitializer1.types new file mode 100644 index 00000000000..68fe7ce286a --- /dev/null +++ b/tests/baselines/reference/catchClauseWithInitializer1.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/catchClauseWithInitializer1.ts === +try { +} +catch (e = 1) { +>e : any +>1 : 1 +} diff --git a/tests/baselines/reference/catchClauseWithTypeAnnotation.symbols b/tests/baselines/reference/catchClauseWithTypeAnnotation.symbols new file mode 100644 index 00000000000..8358d40a286 --- /dev/null +++ b/tests/baselines/reference/catchClauseWithTypeAnnotation.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/catchClauseWithTypeAnnotation.ts === +try { +} catch (e: any) { +>e : Symbol(e, Decl(catchClauseWithTypeAnnotation.ts, 1, 9)) +} diff --git a/tests/baselines/reference/catchClauseWithTypeAnnotation.types b/tests/baselines/reference/catchClauseWithTypeAnnotation.types new file mode 100644 index 00000000000..74ee8463b92 --- /dev/null +++ b/tests/baselines/reference/catchClauseWithTypeAnnotation.types @@ -0,0 +1,5 @@ +=== tests/cases/compiler/catchClauseWithTypeAnnotation.ts === +try { +} catch (e: any) { +>e : any +} diff --git a/tests/baselines/reference/cf.symbols b/tests/baselines/reference/cf.symbols new file mode 100644 index 00000000000..9c2d73f5134 --- /dev/null +++ b/tests/baselines/reference/cf.symbols @@ -0,0 +1,111 @@ +=== tests/cases/compiler/cf.ts === +function f() { +>f : Symbol(f, Decl(cf.ts, 0, 0)) + + var z; +>z : Symbol(z, Decl(cf.ts, 1, 7)) + + var x=10; +>x : Symbol(x, Decl(cf.ts, 2, 7)) + + var y=3; +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + L1: for (var i=0;i<19;i++) { +>i : Symbol(i, Decl(cf.ts, 5, 16)) +>i : Symbol(i, Decl(cf.ts, 5, 16)) +>i : Symbol(i, Decl(cf.ts, 5, 16)) + + if (y==7) { +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + continue L1; + x=11; +>x : Symbol(x, Decl(cf.ts, 2, 7)) + } + if (y==3) { +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + y++; +>y : Symbol(y, Decl(cf.ts, 3, 7)) + } + else { + y--; +>y : Symbol(y, Decl(cf.ts, 3, 7)) + } + do { + y+=2; +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + if (y==20) { +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + break; + x=12; +>x : Symbol(x, Decl(cf.ts, 2, 7)) + } + } while (y<41); +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + y++; +>y : Symbol(y, Decl(cf.ts, 3, 7)) + } + while (y>2) { +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + y=y>>1; +>y : Symbol(y, Decl(cf.ts, 3, 7)) +>y : Symbol(y, Decl(cf.ts, 3, 7)) + } + L2: try { + L3: if (xx : Symbol(x, Decl(cf.ts, 2, 7)) +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + break L2; + x=13; +>x : Symbol(x, Decl(cf.ts, 2, 7)) + } + else { + break L3; + x=14; +>x : Symbol(x, Decl(cf.ts, 2, 7)) + } + } + catch (e) { +>e : Symbol(e, Decl(cf.ts, 38, 11)) + + x++; +>x : Symbol(x, Decl(cf.ts, 2, 7)) + } + finally { + x+=3; +>x : Symbol(x, Decl(cf.ts, 2, 7)) + } + y++; +>y : Symbol(y, Decl(cf.ts, 3, 7)) + + for (var k=0;k<10;k++) { +>k : Symbol(k, Decl(cf.ts, 45, 12)) +>k : Symbol(k, Decl(cf.ts, 45, 12)) +>k : Symbol(k, Decl(cf.ts, 45, 12)) + + z; +>z : Symbol(z, Decl(cf.ts, 1, 7)) + + break; + } + for (k=0;k<10;k++) { +>k : Symbol(k, Decl(cf.ts, 45, 12)) +>k : Symbol(k, Decl(cf.ts, 45, 12)) +>k : Symbol(k, Decl(cf.ts, 45, 12)) + + if (k==6) { +>k : Symbol(k, Decl(cf.ts, 45, 12)) + + continue; + } + break; + } +} + diff --git a/tests/baselines/reference/cf.types b/tests/baselines/reference/cf.types new file mode 100644 index 00000000000..b1b5b74c2f6 --- /dev/null +++ b/tests/baselines/reference/cf.types @@ -0,0 +1,169 @@ +=== tests/cases/compiler/cf.ts === +function f() { +>f : () => void + + var z; +>z : any + + var x=10; +>x : number +>10 : 10 + + var y=3; +>y : number +>3 : 3 + + L1: for (var i=0;i<19;i++) { +>L1 : any +>i : number +>0 : 0 +>i<19 : boolean +>i : number +>19 : 19 +>i++ : number +>i : number + + if (y==7) { +>y==7 : boolean +>y : number +>7 : 7 + + continue L1; +>L1 : any + + x=11; +>x=11 : 11 +>x : number +>11 : 11 + } + if (y==3) { +>y==3 : boolean +>y : number +>3 : 3 + + y++; +>y++ : number +>y : number + } + else { + y--; +>y-- : number +>y : number + } + do { + y+=2; +>y+=2 : number +>y : number +>2 : 2 + + if (y==20) { +>y==20 : boolean +>y : number +>20 : 20 + + break; + x=12; +>x=12 : 12 +>x : number +>12 : 12 + } + } while (y<41); +>y<41 : boolean +>y : number +>41 : 41 + + y++; +>y++ : number +>y : number + } + while (y>2) { +>y>2 : boolean +>y : number +>2 : 2 + + y=y>>1; +>y=y>>1 : number +>y : number +>y>>1 : number +>y : number +>1 : 1 + } + L2: try { +>L2 : any + + L3: if (xL3 : any +>xx : number +>y : number + + break L2; +>L2 : any + + x=13; +>x=13 : 13 +>x : number +>13 : 13 + } + else { + break L3; +>L3 : any + + x=14; +>x=14 : 14 +>x : number +>14 : 14 + } + } + catch (e) { +>e : any + + x++; +>x++ : number +>x : number + } + finally { + x+=3; +>x+=3 : number +>x : number +>3 : 3 + } + y++; +>y++ : number +>y : number + + for (var k=0;k<10;k++) { +>k : number +>0 : 0 +>k<10 : boolean +>k : number +>10 : 10 +>k++ : number +>k : number + + z; +>z : any + + break; + } + for (k=0;k<10;k++) { +>k=0 : 0 +>k : number +>0 : 0 +>k<10 : boolean +>k : number +>10 : 10 +>k++ : number +>k : number + + if (k==6) { +>k==6 : boolean +>k : number +>6 : 6 + + continue; + } + break; + } +} + diff --git a/tests/baselines/reference/chainedAssignment1.symbols b/tests/baselines/reference/chainedAssignment1.symbols new file mode 100644 index 00000000000..f3ee7814582 --- /dev/null +++ b/tests/baselines/reference/chainedAssignment1.symbols @@ -0,0 +1,55 @@ +=== tests/cases/compiler/chainedAssignment1.ts === +class X { +>X : Symbol(X, Decl(chainedAssignment1.ts, 0, 0)) + + constructor(public z) { } +>z : Symbol(X.z, Decl(chainedAssignment1.ts, 1, 16)) + + a: number; +>a : Symbol(X.a, Decl(chainedAssignment1.ts, 1, 29)) +} + +class Y { +>Y : Symbol(Y, Decl(chainedAssignment1.ts, 3, 1)) + + constructor(public z) { +>z : Symbol(Y.z, Decl(chainedAssignment1.ts, 6, 16)) + } + a: number; +>a : Symbol(Y.a, Decl(chainedAssignment1.ts, 7, 5)) + + b: string; +>b : Symbol(Y.b, Decl(chainedAssignment1.ts, 8, 14)) +} + +class Z { +>Z : Symbol(Z, Decl(chainedAssignment1.ts, 10, 1)) + + z: any; +>z : Symbol(Z.z, Decl(chainedAssignment1.ts, 12, 9)) + + c: string; +>c : Symbol(Z.c, Decl(chainedAssignment1.ts, 13, 11)) +} + +var c1 = new X(3); +>c1 : Symbol(c1, Decl(chainedAssignment1.ts, 17, 3)) +>X : Symbol(X, Decl(chainedAssignment1.ts, 0, 0)) + +var c2 = new Y(5); +>c2 : Symbol(c2, Decl(chainedAssignment1.ts, 18, 3)) +>Y : Symbol(Y, Decl(chainedAssignment1.ts, 3, 1)) + +var c3 = new Z(); +>c3 : Symbol(c3, Decl(chainedAssignment1.ts, 19, 3)) +>Z : Symbol(Z, Decl(chainedAssignment1.ts, 10, 1)) + +c1 = c2 = c3; // a bug made this not report the same error as below +>c1 : Symbol(c1, Decl(chainedAssignment1.ts, 17, 3)) +>c2 : Symbol(c2, Decl(chainedAssignment1.ts, 18, 3)) +>c3 : Symbol(c3, Decl(chainedAssignment1.ts, 19, 3)) + +c2 = c3; // Error TS111: Cannot convert Z to Y +>c2 : Symbol(c2, Decl(chainedAssignment1.ts, 18, 3)) +>c3 : Symbol(c3, Decl(chainedAssignment1.ts, 19, 3)) + diff --git a/tests/baselines/reference/chainedAssignment1.types b/tests/baselines/reference/chainedAssignment1.types new file mode 100644 index 00000000000..7517f34fb51 --- /dev/null +++ b/tests/baselines/reference/chainedAssignment1.types @@ -0,0 +1,63 @@ +=== tests/cases/compiler/chainedAssignment1.ts === +class X { +>X : X + + constructor(public z) { } +>z : any + + a: number; +>a : number +} + +class Y { +>Y : Y + + constructor(public z) { +>z : any + } + a: number; +>a : number + + b: string; +>b : string +} + +class Z { +>Z : Z + + z: any; +>z : any + + c: string; +>c : string +} + +var c1 = new X(3); +>c1 : X +>new X(3) : X +>X : typeof X +>3 : 3 + +var c2 = new Y(5); +>c2 : Y +>new Y(5) : Y +>Y : typeof Y +>5 : 5 + +var c3 = new Z(); +>c3 : Z +>new Z() : Z +>Z : typeof Z + +c1 = c2 = c3; // a bug made this not report the same error as below +>c1 = c2 = c3 : Z +>c1 : X +>c2 = c3 : Z +>c2 : Y +>c3 : Z + +c2 = c3; // Error TS111: Cannot convert Z to Y +>c2 = c3 : Z +>c2 : Y +>c3 : Z + diff --git a/tests/baselines/reference/chainedAssignment3.symbols b/tests/baselines/reference/chainedAssignment3.symbols new file mode 100644 index 00000000000..5dd02828f83 --- /dev/null +++ b/tests/baselines/reference/chainedAssignment3.symbols @@ -0,0 +1,59 @@ +=== tests/cases/compiler/chainedAssignment3.ts === +class A { +>A : Symbol(A, Decl(chainedAssignment3.ts, 0, 0)) + + id: number; +>id : Symbol(A.id, Decl(chainedAssignment3.ts, 0, 9)) +} + +class B extends A { +>B : Symbol(B, Decl(chainedAssignment3.ts, 2, 1)) +>A : Symbol(A, Decl(chainedAssignment3.ts, 0, 0)) + + value: string; +>value : Symbol(B.value, Decl(chainedAssignment3.ts, 4, 19)) +} + +var a: A; +>a : Symbol(a, Decl(chainedAssignment3.ts, 8, 3)) +>A : Symbol(A, Decl(chainedAssignment3.ts, 0, 0)) + +var b: B; +>b : Symbol(b, Decl(chainedAssignment3.ts, 9, 3)) +>B : Symbol(B, Decl(chainedAssignment3.ts, 2, 1)) + +a = b = null; +>a : Symbol(a, Decl(chainedAssignment3.ts, 8, 3)) +>b : Symbol(b, Decl(chainedAssignment3.ts, 9, 3)) + +a = b = new B(); +>a : Symbol(a, Decl(chainedAssignment3.ts, 8, 3)) +>b : Symbol(b, Decl(chainedAssignment3.ts, 9, 3)) +>B : Symbol(B, Decl(chainedAssignment3.ts, 2, 1)) + +b = a = new B(); +>b : Symbol(b, Decl(chainedAssignment3.ts, 9, 3)) +>a : Symbol(a, Decl(chainedAssignment3.ts, 8, 3)) +>B : Symbol(B, Decl(chainedAssignment3.ts, 2, 1)) + +a.id = b.value = null; +>a.id : Symbol(A.id, Decl(chainedAssignment3.ts, 0, 9)) +>a : Symbol(a, Decl(chainedAssignment3.ts, 8, 3)) +>id : Symbol(A.id, Decl(chainedAssignment3.ts, 0, 9)) +>b.value : Symbol(B.value, Decl(chainedAssignment3.ts, 4, 19)) +>b : Symbol(b, Decl(chainedAssignment3.ts, 9, 3)) +>value : Symbol(B.value, Decl(chainedAssignment3.ts, 4, 19)) + +// error cases +b = a = new A(); +>b : Symbol(b, Decl(chainedAssignment3.ts, 9, 3)) +>a : Symbol(a, Decl(chainedAssignment3.ts, 8, 3)) +>A : Symbol(A, Decl(chainedAssignment3.ts, 0, 0)) + +a = b = new A(); +>a : Symbol(a, Decl(chainedAssignment3.ts, 8, 3)) +>b : Symbol(b, Decl(chainedAssignment3.ts, 9, 3)) +>A : Symbol(A, Decl(chainedAssignment3.ts, 0, 0)) + + + diff --git a/tests/baselines/reference/chainedAssignment3.types b/tests/baselines/reference/chainedAssignment3.types new file mode 100644 index 00000000000..1e6c858ac0c --- /dev/null +++ b/tests/baselines/reference/chainedAssignment3.types @@ -0,0 +1,77 @@ +=== tests/cases/compiler/chainedAssignment3.ts === +class A { +>A : A + + id: number; +>id : number +} + +class B extends A { +>B : B +>A : A + + value: string; +>value : string +} + +var a: A; +>a : A +>A : A + +var b: B; +>b : B +>B : B + +a = b = null; +>a = b = null : null +>a : A +>b = null : null +>b : B +>null : null + +a = b = new B(); +>a = b = new B() : B +>a : A +>b = new B() : B +>b : B +>new B() : B +>B : typeof B + +b = a = new B(); +>b = a = new B() : B +>b : B +>a = new B() : B +>a : A +>new B() : B +>B : typeof B + +a.id = b.value = null; +>a.id = b.value = null : null +>a.id : number +>a : A +>id : number +>b.value = null : null +>b.value : string +>b : B +>value : string +>null : null + +// error cases +b = a = new A(); +>b = a = new A() : A +>b : B +>a = new A() : A +>a : A +>new A() : A +>A : typeof A + +a = b = new A(); +>a = b = new A() : A +>a : A +>b = new A() : A +>b : B +>new A() : A +>A : typeof A + + + diff --git a/tests/baselines/reference/chainedAssignmentChecking.symbols b/tests/baselines/reference/chainedAssignmentChecking.symbols new file mode 100644 index 00000000000..8b23acb7a2b --- /dev/null +++ b/tests/baselines/reference/chainedAssignmentChecking.symbols @@ -0,0 +1,51 @@ +=== tests/cases/compiler/chainedAssignmentChecking.ts === +class X { +>X : Symbol(X, Decl(chainedAssignmentChecking.ts, 0, 0)) + + constructor(public z) { } +>z : Symbol(X.z, Decl(chainedAssignmentChecking.ts, 1, 14)) + + a: number; +>a : Symbol(X.a, Decl(chainedAssignmentChecking.ts, 1, 27)) +} + +class Y { +>Y : Symbol(Y, Decl(chainedAssignmentChecking.ts, 3, 1)) + + constructor(public z) { } +>z : Symbol(Y.z, Decl(chainedAssignmentChecking.ts, 6, 14)) + + a: number; +>a : Symbol(Y.a, Decl(chainedAssignmentChecking.ts, 6, 27)) + + b: string; +>b : Symbol(Y.b, Decl(chainedAssignmentChecking.ts, 7, 12)) +} + +class Z { +>Z : Symbol(Z, Decl(chainedAssignmentChecking.ts, 9, 1)) + + z: any; +>z : Symbol(Z.z, Decl(chainedAssignmentChecking.ts, 11, 9)) + + c: string; +>c : Symbol(Z.c, Decl(chainedAssignmentChecking.ts, 12, 9)) +} + +var c1 = new X(3); +>c1 : Symbol(c1, Decl(chainedAssignmentChecking.ts, 16, 3)) +>X : Symbol(X, Decl(chainedAssignmentChecking.ts, 0, 0)) + +var c2 = new Y(5); +>c2 : Symbol(c2, Decl(chainedAssignmentChecking.ts, 17, 3)) +>Y : Symbol(Y, Decl(chainedAssignmentChecking.ts, 3, 1)) + +var c3 = new Z(); +>c3 : Symbol(c3, Decl(chainedAssignmentChecking.ts, 18, 3)) +>Z : Symbol(Z, Decl(chainedAssignmentChecking.ts, 9, 1)) + +c1 = c2 = c3; // Should be error +>c1 : Symbol(c1, Decl(chainedAssignmentChecking.ts, 16, 3)) +>c2 : Symbol(c2, Decl(chainedAssignmentChecking.ts, 17, 3)) +>c3 : Symbol(c3, Decl(chainedAssignmentChecking.ts, 18, 3)) + diff --git a/tests/baselines/reference/chainedAssignmentChecking.types b/tests/baselines/reference/chainedAssignmentChecking.types new file mode 100644 index 00000000000..b9e8529f617 --- /dev/null +++ b/tests/baselines/reference/chainedAssignmentChecking.types @@ -0,0 +1,58 @@ +=== tests/cases/compiler/chainedAssignmentChecking.ts === +class X { +>X : X + + constructor(public z) { } +>z : any + + a: number; +>a : number +} + +class Y { +>Y : Y + + constructor(public z) { } +>z : any + + a: number; +>a : number + + b: string; +>b : string +} + +class Z { +>Z : Z + + z: any; +>z : any + + c: string; +>c : string +} + +var c1 = new X(3); +>c1 : X +>new X(3) : X +>X : typeof X +>3 : 3 + +var c2 = new Y(5); +>c2 : Y +>new Y(5) : Y +>Y : typeof Y +>5 : 5 + +var c3 = new Z(); +>c3 : Z +>new Z() : Z +>Z : typeof Z + +c1 = c2 = c3; // Should be error +>c1 = c2 = c3 : Z +>c1 : X +>c2 = c3 : Z +>c2 : Y +>c3 : Z + diff --git a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.symbols b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.symbols new file mode 100644 index 00000000000..c4a3f7b5f4d --- /dev/null +++ b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.symbols @@ -0,0 +1,65 @@ +=== tests/cases/compiler/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts === +class Chain { +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 0, 0)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 0, 12)) +>A : Symbol(A, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 5, 1)) + + constructor(public value: T) { } +>value : Symbol(Chain.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 16)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 0, 12)) + + then(cb: (x: T) => S): Chain { +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 36)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 2, 9)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 0, 12)) +>cb : Symbol(cb, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 2, 22)) +>x : Symbol(x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 2, 27)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 0, 12)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 2, 9)) +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 0, 0)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 2, 9)) + + return null; + } +} + +class A { +>A : Symbol(A, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 5, 1)) + + x; +>x : Symbol(A.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 7, 9)) +} +class B extends A { +>B : Symbol(B, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 9, 1)) +>A : Symbol(A, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 5, 1)) + + y; +>y : Symbol(B.y, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 10, 19)) +} +class C extends B { +>C : Symbol(C, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 12, 1)) +>B : Symbol(B, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 9, 1)) + + z; +>z : Symbol(C.z, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 13, 19)) +} + +// Ok to go down the chain, but error to try to climb back up +(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then(b => new A); +>(new Chain(new A)).then(a => new B).then(b => new C).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 36)) +>(new Chain(new A)).then(a => new B).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 36)) +>(new Chain(new A)).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 36)) +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 0, 0)) +>A : Symbol(A, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 5, 1)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 36)) +>a : Symbol(a, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 18, 24)) +>B : Symbol(B, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 9, 1)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 36)) +>b : Symbol(b, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 18, 41)) +>C : Symbol(C, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 12, 1)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 1, 36)) +>c : Symbol(c, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 18, 58)) +>B : Symbol(B, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 9, 1)) +>b : Symbol(b, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 18, 75)) +>A : Symbol(A, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts, 5, 1)) + diff --git a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types new file mode 100644 index 00000000000..53ebb6e2150 --- /dev/null +++ b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.types @@ -0,0 +1,83 @@ +=== tests/cases/compiler/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter.ts === +class Chain { +>Chain : Chain +>T : T +>A : A + + constructor(public value: T) { } +>value : T +>T : T + + then(cb: (x: T) => S): Chain { +>then : (cb: (x: T) => S) => Chain +>S : S +>T : T +>cb : (x: T) => S +>x : T +>T : T +>S : S +>Chain : Chain +>S : S + + return null; +>null : null + } +} + +class A { +>A : A + + x; +>x : any +} +class B extends A { +>B : B +>A : A + + y; +>y : any +} +class C extends B { +>C : C +>B : B + + z; +>z : any +} + +// Ok to go down the chain, but error to try to climb back up +(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then(b => new A); +>(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then(b => new A) : any +>(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B).then : any +>(new Chain(new A)).then(a => new B).then(b => new C).then(c => new B) : any +>(new Chain(new A)).then(a => new B).then(b => new C).then : (cb: (x: C) => S) => Chain +>(new Chain(new A)).then(a => new B).then(b => new C) : Chain +>(new Chain(new A)).then(a => new B).then : (cb: (x: B) => S) => Chain +>(new Chain(new A)).then(a => new B) : Chain +>(new Chain(new A)).then : (cb: (x: A) => S) => Chain +>(new Chain(new A)) : Chain +>new Chain(new A) : Chain +>Chain : typeof Chain +>new A : A +>A : typeof A +>then : (cb: (x: A) => S) => Chain +>a => new B : (a: A) => B +>a : A +>new B : B +>B : typeof B +>then : (cb: (x: B) => S) => Chain +>b => new C : (b: B) => C +>b : B +>new C : C +>C : typeof C +>then : (cb: (x: C) => S) => Chain +>c => new B : (c: C) => B +>c : C +>new B : B +>B : typeof B +>then : any +>b => new A : (b: any) => A +>b : any +>new A : A +>A : typeof A + diff --git a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.symbols b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.symbols new file mode 100644 index 00000000000..e8affe5f84f --- /dev/null +++ b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.symbols @@ -0,0 +1,197 @@ +=== tests/cases/compiler/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts === +class Chain { +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 0)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 12)) + + constructor(public value: T) { } +>value : Symbol(Chain.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 16)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 12)) + + then(cb: (x: T) => S): Chain { +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 2, 9)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 12)) +>cb : Symbol(cb, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 2, 22)) +>x : Symbol(x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 2, 27)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 12)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 2, 9)) +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 0)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 2, 9)) + + var t: T; +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 12)) + + var s: S; +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 4, 11)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 2, 9)) + + // Ok to go down the chain, but error to climb up the chain + (new Chain(t)).then(tt => s).then(ss => t); +>(new Chain(t)).then(tt => s).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>(new Chain(t)).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 0)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 6, 28)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 4, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 6, 42)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) + + // But error to try to climb up the chain + (new Chain(s)).then(ss => t); +>(new Chain(s)).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 0)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 4, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 9, 28)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) + + // Staying at T or S should be fine + (new Chain(t)).then(tt => t).then(tt => t).then(tt => t); +>(new Chain(t)).then(tt => t).then(tt => t).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>(new Chain(t)).then(tt => t).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>(new Chain(t)).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 0)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 12, 28)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 12, 42)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 12, 56)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 3, 11)) + + (new Chain(s)).then(ss => s).then(ss => s).then(ss => s); +>(new Chain(s)).then(ss => s).then(ss => s).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>(new Chain(s)).then(ss => s).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>(new Chain(s)).then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>Chain : Symbol(Chain, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 0, 0)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 4, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 13, 28)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 4, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 13, 42)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 4, 11)) +>then : Symbol(Chain.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 1, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 13, 56)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 4, 11)) + + return null; + } +} + +// Similar to above, but T is now constrained. Verify that the constraint is maintained across invocations +interface I { +>I : Symbol(I, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 17, 1)) + + x: number; +>x : Symbol(I.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 20, 13)) +} +class Chain2 { +>Chain2 : Symbol(Chain2, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 22, 1)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 23, 13)) +>I : Symbol(I, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 17, 1)) + + constructor(public value: T) { } +>value : Symbol(Chain2.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 16)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 23, 13)) + + then(cb: (x: T) => S): Chain2 { +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 25, 9)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 23, 13)) +>cb : Symbol(cb, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 25, 22)) +>x : Symbol(x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 25, 27)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 23, 13)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 25, 9)) +>Chain2 : Symbol(Chain2, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 22, 1)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 25, 9)) + + var i: I; +>i : Symbol(i, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 26, 11)) +>I : Symbol(I, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 17, 1)) + + var t: T; +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 27, 11)) +>T : Symbol(T, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 23, 13)) + + var s: S; +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 28, 11)) +>S : Symbol(S, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 25, 9)) + + // Ok to go down the chain, check the constraint at the end. + // Should get an error that we are assigning a string to a number + (new Chain2(i)).then(ii => t).then(tt => s).value.x = ""; +>(new Chain2(i)).then(ii => t).then(tt => s).value.x : Symbol(I.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 20, 13)) +>(new Chain2(i)).then(ii => t).then(tt => s).value : Symbol(Chain2.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 16)) +>(new Chain2(i)).then(ii => t).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>(new Chain2(i)).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>Chain2 : Symbol(Chain2, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 22, 1)) +>i : Symbol(i, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 26, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>ii : Symbol(ii, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 31, 29)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 27, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 31, 43)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 28, 11)) +>value : Symbol(Chain2.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 16)) +>x : Symbol(I.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 20, 13)) + + // Staying at T or S should keep the constraint. + // Get an error when we assign a string to a number in both cases + (new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t).value.x = ""; +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t).value.x : Symbol(I.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 20, 13)) +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t).value : Symbol(Chain2.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 16)) +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>(new Chain2(i)).then(ii => t).then(tt => t).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>(new Chain2(i)).then(ii => t).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>(new Chain2(i)).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>Chain2 : Symbol(Chain2, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 22, 1)) +>i : Symbol(i, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 26, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>ii : Symbol(ii, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 35, 29)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 27, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 35, 43)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 27, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 35, 57)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 27, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>tt : Symbol(tt, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 35, 71)) +>t : Symbol(t, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 27, 11)) +>value : Symbol(Chain2.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 16)) +>x : Symbol(I.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 20, 13)) + + (new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s).value.x = ""; +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s).value.x : Symbol(I.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 20, 13)) +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s).value : Symbol(Chain2.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 16)) +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>(new Chain2(i)).then(ii => s).then(ss => s).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>(new Chain2(i)).then(ii => s).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>(new Chain2(i)).then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>Chain2 : Symbol(Chain2, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 22, 1)) +>i : Symbol(i, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 26, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>ii : Symbol(ii, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 36, 29)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 28, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 36, 43)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 28, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 36, 57)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 28, 11)) +>then : Symbol(Chain2.then, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 36)) +>ss : Symbol(ss, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 36, 71)) +>s : Symbol(s, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 28, 11)) +>value : Symbol(Chain2.value, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 24, 16)) +>x : Symbol(I.x, Decl(chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts, 20, 13)) + + return null; + } +} diff --git a/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types new file mode 100644 index 00000000000..5dc0ddb54c0 --- /dev/null +++ b/tests/baselines/reference/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.types @@ -0,0 +1,257 @@ +=== tests/cases/compiler/chainedCallsWithTypeParameterConstrainedToOtherTypeParameter2.ts === +class Chain { +>Chain : Chain +>T : T + + constructor(public value: T) { } +>value : T +>T : T + + then(cb: (x: T) => S): Chain { +>then : (cb: (x: T) => S) => Chain +>S : S +>T : T +>cb : (x: T) => S +>x : T +>T : T +>S : S +>Chain : Chain +>S : S + + var t: T; +>t : T +>T : T + + var s: S; +>s : S +>S : S + + // Ok to go down the chain, but error to climb up the chain + (new Chain(t)).then(tt => s).then(ss => t); +>(new Chain(t)).then(tt => s).then(ss => t) : any +>(new Chain(t)).then(tt => s).then : (cb: (x: S) => S) => Chain +>(new Chain(t)).then(tt => s) : Chain +>(new Chain(t)).then : (cb: (x: T) => S) => Chain +>(new Chain(t)) : Chain +>new Chain(t) : Chain +>Chain : typeof Chain +>t : T +>then : (cb: (x: T) => S) => Chain +>tt => s : (tt: T) => S +>tt : T +>s : S +>then : (cb: (x: S) => S) => Chain +>ss => t : (ss: S) => T +>ss : S +>t : T + + // But error to try to climb up the chain + (new Chain(s)).then(ss => t); +>(new Chain(s)).then(ss => t) : any +>(new Chain(s)).then : (cb: (x: S) => S) => Chain +>(new Chain(s)) : Chain +>new Chain(s) : Chain +>Chain : typeof Chain +>s : S +>then : (cb: (x: S) => S) => Chain +>ss => t : (ss: S) => T +>ss : S +>t : T + + // Staying at T or S should be fine + (new Chain(t)).then(tt => t).then(tt => t).then(tt => t); +>(new Chain(t)).then(tt => t).then(tt => t).then(tt => t) : Chain +>(new Chain(t)).then(tt => t).then(tt => t).then : (cb: (x: T) => S) => Chain +>(new Chain(t)).then(tt => t).then(tt => t) : Chain +>(new Chain(t)).then(tt => t).then : (cb: (x: T) => S) => Chain +>(new Chain(t)).then(tt => t) : Chain +>(new Chain(t)).then : (cb: (x: T) => S) => Chain +>(new Chain(t)) : Chain +>new Chain(t) : Chain +>Chain : typeof Chain +>t : T +>then : (cb: (x: T) => S) => Chain +>tt => t : (tt: T) => T +>tt : T +>t : T +>then : (cb: (x: T) => S) => Chain +>tt => t : (tt: T) => T +>tt : T +>t : T +>then : (cb: (x: T) => S) => Chain +>tt => t : (tt: T) => T +>tt : T +>t : T + + (new Chain(s)).then(ss => s).then(ss => s).then(ss => s); +>(new Chain(s)).then(ss => s).then(ss => s).then(ss => s) : Chain +>(new Chain(s)).then(ss => s).then(ss => s).then : (cb: (x: S) => S) => Chain +>(new Chain(s)).then(ss => s).then(ss => s) : Chain +>(new Chain(s)).then(ss => s).then : (cb: (x: S) => S) => Chain +>(new Chain(s)).then(ss => s) : Chain +>(new Chain(s)).then : (cb: (x: S) => S) => Chain +>(new Chain(s)) : Chain +>new Chain(s) : Chain +>Chain : typeof Chain +>s : S +>then : (cb: (x: S) => S) => Chain +>ss => s : (ss: S) => S +>ss : S +>s : S +>then : (cb: (x: S) => S) => Chain +>ss => s : (ss: S) => S +>ss : S +>s : S +>then : (cb: (x: S) => S) => Chain +>ss => s : (ss: S) => S +>ss : S +>s : S + + return null; +>null : null + } +} + +// Similar to above, but T is now constrained. Verify that the constraint is maintained across invocations +interface I { +>I : I + + x: number; +>x : number +} +class Chain2 { +>Chain2 : Chain2 +>T : T +>I : I + + constructor(public value: T) { } +>value : T +>T : T + + then(cb: (x: T) => S): Chain2 { +>then : (cb: (x: T) => S) => Chain2 +>S : S +>T : T +>cb : (x: T) => S +>x : T +>T : T +>S : S +>Chain2 : Chain2 +>S : S + + var i: I; +>i : I +>I : I + + var t: T; +>t : T +>T : T + + var s: S; +>s : S +>S : S + + // Ok to go down the chain, check the constraint at the end. + // Should get an error that we are assigning a string to a number + (new Chain2(i)).then(ii => t).then(tt => s).value.x = ""; +>(new Chain2(i)).then(ii => t).then(tt => s).value.x = "" : "" +>(new Chain2(i)).then(ii => t).then(tt => s).value.x : number +>(new Chain2(i)).then(ii => t).then(tt => s).value : S +>(new Chain2(i)).then(ii => t).then(tt => s) : Chain2 +>(new Chain2(i)).then(ii => t).then : (cb: (x: T) => S) => Chain2 +>(new Chain2(i)).then(ii => t) : Chain2 +>(new Chain2(i)).then : (cb: (x: I) => S) => Chain2 +>(new Chain2(i)) : Chain2 +>new Chain2(i) : Chain2 +>Chain2 : typeof Chain2 +>i : I +>then : (cb: (x: I) => S) => Chain2 +>ii => t : (ii: I) => T +>ii : I +>t : T +>then : (cb: (x: T) => S) => Chain2 +>tt => s : (tt: T) => S +>tt : T +>s : S +>value : S +>x : number +>"" : "" + + // Staying at T or S should keep the constraint. + // Get an error when we assign a string to a number in both cases + (new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t).value.x = ""; +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t).value.x = "" : "" +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t).value.x : number +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t).value : T +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then(tt => t) : Chain2 +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t).then : (cb: (x: T) => S) => Chain2 +>(new Chain2(i)).then(ii => t).then(tt => t).then(tt => t) : Chain2 +>(new Chain2(i)).then(ii => t).then(tt => t).then : (cb: (x: T) => S) => Chain2 +>(new Chain2(i)).then(ii => t).then(tt => t) : Chain2 +>(new Chain2(i)).then(ii => t).then : (cb: (x: T) => S) => Chain2 +>(new Chain2(i)).then(ii => t) : Chain2 +>(new Chain2(i)).then : (cb: (x: I) => S) => Chain2 +>(new Chain2(i)) : Chain2 +>new Chain2(i) : Chain2 +>Chain2 : typeof Chain2 +>i : I +>then : (cb: (x: I) => S) => Chain2 +>ii => t : (ii: I) => T +>ii : I +>t : T +>then : (cb: (x: T) => S) => Chain2 +>tt => t : (tt: T) => T +>tt : T +>t : T +>then : (cb: (x: T) => S) => Chain2 +>tt => t : (tt: T) => T +>tt : T +>t : T +>then : (cb: (x: T) => S) => Chain2 +>tt => t : (tt: T) => T +>tt : T +>t : T +>value : T +>x : number +>"" : "" + + (new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s).value.x = ""; +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s).value.x = "" : "" +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s).value.x : number +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s).value : S +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then(ss => s) : Chain2 +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s).then : (cb: (x: S) => S) => Chain2 +>(new Chain2(i)).then(ii => s).then(ss => s).then(ss => s) : Chain2 +>(new Chain2(i)).then(ii => s).then(ss => s).then : (cb: (x: S) => S) => Chain2 +>(new Chain2(i)).then(ii => s).then(ss => s) : Chain2 +>(new Chain2(i)).then(ii => s).then : (cb: (x: S) => S) => Chain2 +>(new Chain2(i)).then(ii => s) : Chain2 +>(new Chain2(i)).then : (cb: (x: I) => S) => Chain2 +>(new Chain2(i)) : Chain2 +>new Chain2(i) : Chain2 +>Chain2 : typeof Chain2 +>i : I +>then : (cb: (x: I) => S) => Chain2 +>ii => s : (ii: I) => S +>ii : I +>s : S +>then : (cb: (x: S) => S) => Chain2 +>ss => s : (ss: S) => S +>ss : S +>s : S +>then : (cb: (x: S) => S) => Chain2 +>ss => s : (ss: S) => S +>ss : S +>s : S +>then : (cb: (x: S) => S) => Chain2 +>ss => s : (ss: S) => S +>ss : S +>s : S +>value : S +>x : number +>"" : "" + + return null; +>null : null + } +} diff --git a/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.symbols b/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.symbols index c9ee830a9a5..4146ee56e62 100644 --- a/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.symbols +++ b/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.symbols @@ -2,16 +2,30 @@ someFunction(function(BaseClass) { >BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) - class Hello extends BaseClass { ->Hello : Symbol(Hello, Decl(weird.js, 0, 34)) + 'use strict'; + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + + class Hello extends BaseClass { +>Hello : Symbol(Hello, Decl(weird.js, 2, 35)) >BaseClass : Symbol(BaseClass, Decl(weird.js, 0, 22)) - constructor() { - this.foo = "bar"; ->this.foo : Symbol(Hello.foo, Decl(weird.js, 2, 17)) ->this : Symbol(Hello, Decl(weird.js, 0, 34)) ->foo : Symbol(Hello.foo, Decl(weird.js, 2, 17)) - } - } + constructor() { + super(); + this.foo = "bar"; +>this.foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) +>this : Symbol(Hello, Decl(weird.js, 2, 35)) +>foo : Symbol(Hello.foo, Decl(weird.js, 5, 20)) + } + _render(error) { +>_render : Symbol(Hello._render, Decl(weird.js, 7, 9)) +>error : Symbol(error, Decl(weird.js, 8, 16)) + + const message = error.message || DEFAULT_MESSAGE; +>message : Symbol(message, Decl(weird.js, 9, 17)) +>error : Symbol(error, Decl(weird.js, 8, 16)) +>DEFAULT_MESSAGE : Symbol(DEFAULT_MESSAGE, Decl(weird.js, 2, 9)) + } + } }); diff --git a/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.types b/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.types index 6a0a5ad1479..5d58047f6e4 100644 --- a/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.types +++ b/tests/baselines/reference/checkIndexConstraintOfJavascriptClassExpression.types @@ -1,22 +1,45 @@ === tests/cases/compiler/weird.js === someFunction(function(BaseClass) { ->someFunction(function(BaseClass) { class Hello extends BaseClass { constructor() { this.foo = "bar"; } }}) : any +>someFunction(function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }}) : any >someFunction : any ->function(BaseClass) { class Hello extends BaseClass { constructor() { this.foo = "bar"; } }} : (BaseClass: any) => void +>function(BaseClass) { 'use strict'; const DEFAULT_MESSAGE = "nop!"; class Hello extends BaseClass { constructor() { super(); this.foo = "bar"; } _render(error) { const message = error.message || DEFAULT_MESSAGE; } }} : (BaseClass: any) => void >BaseClass : any - class Hello extends BaseClass { + 'use strict'; +>'use strict' : "use strict" + + const DEFAULT_MESSAGE = "nop!"; +>DEFAULT_MESSAGE : "nop!" +>"nop!" : "nop!" + + class Hello extends BaseClass { >Hello : Hello >BaseClass : any - constructor() { - this.foo = "bar"; + constructor() { + super(); +>super() : void +>super : any + + this.foo = "bar"; >this.foo = "bar" : "bar" >this.foo : string >this : this >foo : string >"bar" : "bar" - } - } + } + _render(error) { +>_render : (error: any) => void +>error : any + + const message = error.message || DEFAULT_MESSAGE; +>message : any +>error.message || DEFAULT_MESSAGE : any +>error.message : any +>error : any +>message : any +>DEFAULT_MESSAGE : "nop!" + } + } }); diff --git a/tests/baselines/reference/checkJsFiles.symbols b/tests/baselines/reference/checkJsFiles.symbols new file mode 100644 index 00000000000..c234a5a3e13 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/a.js === +var x = "string"; +>x : Symbol(x, Decl(a.js, 0, 3)) + +x = 0; +>x : Symbol(x, Decl(a.js, 0, 3)) + diff --git a/tests/baselines/reference/checkJsFiles.types b/tests/baselines/reference/checkJsFiles.types new file mode 100644 index 00000000000..10159b5d065 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles.types @@ -0,0 +1,10 @@ +=== tests/cases/compiler/a.js === +var x = "string"; +>x : string +>"string" : "string" + +x = 0; +>x = 0 : 0 +>x : string +>0 : 0 + diff --git a/tests/baselines/reference/checkJsFiles2.symbols b/tests/baselines/reference/checkJsFiles2.symbols new file mode 100644 index 00000000000..e70fee49153 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles2.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/a.js === +// @ts-check +var x = "string"; +>x : Symbol(x, Decl(a.js, 1, 3)) + +x = 0; +>x : Symbol(x, Decl(a.js, 1, 3)) + diff --git a/tests/baselines/reference/checkJsFiles2.types b/tests/baselines/reference/checkJsFiles2.types new file mode 100644 index 00000000000..e5aa1997663 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles2.types @@ -0,0 +1,11 @@ +=== tests/cases/compiler/a.js === +// @ts-check +var x = "string"; +>x : string +>"string" : "string" + +x = 0; +>x = 0 : 0 +>x : string +>0 : 0 + diff --git a/tests/baselines/reference/checkJsFiles3.symbols b/tests/baselines/reference/checkJsFiles3.symbols new file mode 100644 index 00000000000..e70fee49153 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles3.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/a.js === +// @ts-check +var x = "string"; +>x : Symbol(x, Decl(a.js, 1, 3)) + +x = 0; +>x : Symbol(x, Decl(a.js, 1, 3)) + diff --git a/tests/baselines/reference/checkJsFiles3.types b/tests/baselines/reference/checkJsFiles3.types new file mode 100644 index 00000000000..e5aa1997663 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles3.types @@ -0,0 +1,11 @@ +=== tests/cases/compiler/a.js === +// @ts-check +var x = "string"; +>x : string +>"string" : "string" + +x = 0; +>x = 0 : 0 +>x : string +>0 : 0 + diff --git a/tests/baselines/reference/checkJsFiles4.symbols b/tests/baselines/reference/checkJsFiles4.symbols new file mode 100644 index 00000000000..e70fee49153 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles4.symbols @@ -0,0 +1,8 @@ +=== tests/cases/compiler/a.js === +// @ts-check +var x = "string"; +>x : Symbol(x, Decl(a.js, 1, 3)) + +x = 0; +>x : Symbol(x, Decl(a.js, 1, 3)) + diff --git a/tests/baselines/reference/checkJsFiles4.types b/tests/baselines/reference/checkJsFiles4.types new file mode 100644 index 00000000000..e5aa1997663 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles4.types @@ -0,0 +1,11 @@ +=== tests/cases/compiler/a.js === +// @ts-check +var x = "string"; +>x : string +>"string" : "string" + +x = 0; +>x = 0 : 0 +>x : string +>0 : 0 + diff --git a/tests/baselines/reference/checkJsFiles_noErrorLocation.symbols b/tests/baselines/reference/checkJsFiles_noErrorLocation.symbols new file mode 100644 index 00000000000..a2cd8a0b7ac --- /dev/null +++ b/tests/baselines/reference/checkJsFiles_noErrorLocation.symbols @@ -0,0 +1,39 @@ +=== tests/cases/compiler/a.js === +// @ts-check +class A { +>A : Symbol(A, Decl(a.js, 0, 0)) + + constructor() { + + } + foo() { +>foo : Symbol(A.foo, Decl(a.js, 4, 3)) + + return 4; + } +} + +class B extends A { +>B : Symbol(B, Decl(a.js, 8, 1)) +>A : Symbol(A, Decl(a.js, 0, 0)) + + constructor() { + super(); +>super : Symbol(A, Decl(a.js, 0, 0)) + + this.foo = () => 3; +>this.foo : Symbol(B.foo, Decl(a.js, 12, 12)) +>this : Symbol(B, Decl(a.js, 8, 1)) +>foo : Symbol(B.foo, Decl(a.js, 12, 12)) + } +} + +const i = new B(); +>i : Symbol(i, Decl(a.js, 17, 5)) +>B : Symbol(B, Decl(a.js, 8, 1)) + +i.foo(); +>i.foo : Symbol(B.foo, Decl(a.js, 12, 12)) +>i : Symbol(i, Decl(a.js, 17, 5)) +>foo : Symbol(B.foo, Decl(a.js, 12, 12)) + diff --git a/tests/baselines/reference/checkJsFiles_noErrorLocation.types b/tests/baselines/reference/checkJsFiles_noErrorLocation.types new file mode 100644 index 00000000000..d714782fed1 --- /dev/null +++ b/tests/baselines/reference/checkJsFiles_noErrorLocation.types @@ -0,0 +1,46 @@ +=== tests/cases/compiler/a.js === +// @ts-check +class A { +>A : A + + constructor() { + + } + foo() { +>foo : () => number + + return 4; +>4 : 4 + } +} + +class B extends A { +>B : B +>A : A + + constructor() { + super(); +>super() : void +>super : typeof A + + this.foo = () => 3; +>this.foo = () => 3 : () => number +>this.foo : () => number +>this : this +>foo : () => number +>() => 3 : () => number +>3 : 3 + } +} + +const i = new B(); +>i : B +>new B() : B +>B : typeof B + +i.foo(); +>i.foo() : number +>i.foo : () => number +>i : B +>foo : () => number + diff --git a/tests/baselines/reference/checkJsdocTypeTag2.symbols b/tests/baselines/reference/checkJsdocTypeTag2.symbols new file mode 100644 index 00000000000..ed35232f445 --- /dev/null +++ b/tests/baselines/reference/checkJsdocTypeTag2.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/jsdoc/0.js === +// @ts-check +/** @type {String} */ +var S = true; +>S : Symbol(S, Decl(0.js, 2, 3)) + +/** @type {number} */ +var n = "hello"; +>n : Symbol(n, Decl(0.js, 5, 3)) + +/** @type {function (number)} */ +const x1 = (a) => a + 1; +>x1 : Symbol(x1, Decl(0.js, 8, 5)) +>a : Symbol(a, Decl(0.js, 8, 12)) +>a : Symbol(a, Decl(0.js, 8, 12)) + +x1("string"); +>x1 : Symbol(x1, Decl(0.js, 8, 5)) + +/** @type {function (number): number} */ +const x2 = (a) => a + 1; +>x2 : Symbol(x2, Decl(0.js, 12, 5)) +>a : Symbol(a, Decl(0.js, 12, 12)) +>a : Symbol(a, Decl(0.js, 12, 12)) + +/** @type {string} */ +var a; +>a : Symbol(a, Decl(0.js, 15, 3)) + +a = x2(0); +>a : Symbol(a, Decl(0.js, 15, 3)) +>x2 : Symbol(x2, Decl(0.js, 12, 5)) + +/** @type {function (number): number} */ +const x3 = (a) => a.concat("hi"); +>x3 : Symbol(x3, Decl(0.js, 19, 5)) +>a : Symbol(a, Decl(0.js, 19, 12)) +>a : Symbol(a, Decl(0.js, 19, 12)) + +x3(0); +>x3 : Symbol(x3, Decl(0.js, 19, 5)) + +/** @type {function (number): string} */ +const x4 = (a) => a + 1; +>x4 : Symbol(x4, Decl(0.js, 23, 5)) +>a : Symbol(a, Decl(0.js, 23, 12)) +>a : Symbol(a, Decl(0.js, 23, 12)) + +x4(0); +>x4 : Symbol(x4, Decl(0.js, 23, 5)) + diff --git a/tests/baselines/reference/checkJsdocTypeTag2.types b/tests/baselines/reference/checkJsdocTypeTag2.types new file mode 100644 index 00000000000..dfee596ca4e --- /dev/null +++ b/tests/baselines/reference/checkJsdocTypeTag2.types @@ -0,0 +1,76 @@ +=== tests/cases/conformance/jsdoc/0.js === +// @ts-check +/** @type {String} */ +var S = true; +>S : string +>true : true + +/** @type {number} */ +var n = "hello"; +>n : number +>"hello" : "hello" + +/** @type {function (number)} */ +const x1 = (a) => a + 1; +>x1 : (arg0: number) => any +>(a) => a + 1 : (a: number) => number +>a : number +>a + 1 : number +>a : number +>1 : 1 + +x1("string"); +>x1("string") : any +>x1 : (arg0: number) => any +>"string" : "string" + +/** @type {function (number): number} */ +const x2 = (a) => a + 1; +>x2 : (arg0: number) => number +>(a) => a + 1 : (a: number) => number +>a : number +>a + 1 : number +>a : number +>1 : 1 + +/** @type {string} */ +var a; +>a : string + +a = x2(0); +>a = x2(0) : number +>a : string +>x2(0) : number +>x2 : (arg0: number) => number +>0 : 0 + +/** @type {function (number): number} */ +const x3 = (a) => a.concat("hi"); +>x3 : (arg0: number) => number +>(a) => a.concat("hi") : (a: number) => any +>a : number +>a.concat("hi") : any +>a.concat : any +>a : number +>concat : any +>"hi" : "hi" + +x3(0); +>x3(0) : number +>x3 : (arg0: number) => number +>0 : 0 + +/** @type {function (number): string} */ +const x4 = (a) => a + 1; +>x4 : (arg0: number) => string +>(a) => a + 1 : (a: number) => number +>a : number +>a + 1 : number +>a : number +>1 : 1 + +x4(0); +>x4(0) : string +>x4 : (arg0: number) => string +>0 : 0 + diff --git a/tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.symbols b/tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.symbols new file mode 100644 index 00000000000..603b395a755 --- /dev/null +++ b/tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.symbols @@ -0,0 +1,51 @@ +=== tests/cases/conformance/jsdoc/0.js === +// @ts-check +var lol; +>lol : Symbol(lol, Decl(0.js, 1, 3)) + +const obj = { +>obj : Symbol(obj, Decl(0.js, 2, 5)) + + /** @type {string|undefined} */ + bar: 42, +>bar : Symbol(bar, Decl(0.js, 2, 13)) + + /** @type {function(number): number} */ + method1(n1) { +>method1 : Symbol(method1, Decl(0.js, 4, 10)) +>n1 : Symbol(n1, Decl(0.js, 6, 10)) + + return "42"; + }, + /** @type {function(number): number} */ + method2: (n1) => "lol", +>method2 : Symbol(method2, Decl(0.js, 8, 4)) +>n1 : Symbol(n1, Decl(0.js, 10, 12)) + + /** @type {function(number): number} */ + arrowFunc: (num="0") => num + 42, +>arrowFunc : Symbol(arrowFunc, Decl(0.js, 10, 25)) +>num : Symbol(num, Decl(0.js, 12, 14)) +>num : Symbol(num, Decl(0.js, 12, 14)) + + /** @type {string} */ + lol +>lol : Symbol(lol, Decl(0.js, 12, 35)) +} +lol = "string" +>lol : Symbol(lol, Decl(0.js, 1, 3)) + +/** @type {string} */ +var s = obj.method1(0); +>s : Symbol(s, Decl(0.js, 18, 3)) +>obj.method1 : Symbol(method1, Decl(0.js, 4, 10)) +>obj : Symbol(obj, Decl(0.js, 2, 5)) +>method1 : Symbol(method1, Decl(0.js, 4, 10)) + +/** @type {string} */ +var s1 = obj.method2("0"); +>s1 : Symbol(s1, Decl(0.js, 21, 3)) +>obj.method2 : Symbol(method2, Decl(0.js, 8, 4)) +>obj : Symbol(obj, Decl(0.js, 2, 5)) +>method2 : Symbol(method2, Decl(0.js, 8, 4)) + diff --git a/tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.types b/tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.types new file mode 100644 index 00000000000..443826c7aeb --- /dev/null +++ b/tests/baselines/reference/checkJsdocTypeTagOnObjectProperty2.types @@ -0,0 +1,67 @@ +=== tests/cases/conformance/jsdoc/0.js === +// @ts-check +var lol; +>lol : any + +const obj = { +>obj : { [x: string]: any; bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; } +>{ /** @type {string|undefined} */ bar: 42, /** @type {function(number): number} */ method1(n1) { return "42"; }, /** @type {function(number): number} */ method2: (n1) => "lol", /** @type {function(number): number} */ arrowFunc: (num="0") => num + 42, /** @type {string} */ lol} : { [x: string]: any; bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; } + + /** @type {string|undefined} */ + bar: 42, +>bar : string | undefined +>42 : 42 + + /** @type {function(number): number} */ + method1(n1) { +>method1 : (n1: any) => string +>n1 : any + + return "42"; +>"42" : "42" + + }, + /** @type {function(number): number} */ + method2: (n1) => "lol", +>method2 : (arg0: number) => number +>(n1) => "lol" : (n1: any) => string +>n1 : any +>"lol" : "lol" + + /** @type {function(number): number} */ + arrowFunc: (num="0") => num + 42, +>arrowFunc : (arg0: number) => number +>(num="0") => num + 42 : (num?: string) => string +>num : string +>"0" : "0" +>num + 42 : string +>num : string +>42 : 42 + + /** @type {string} */ + lol +>lol : string +} +lol = "string" +>lol = "string" : "string" +>lol : any +>"string" : "string" + +/** @type {string} */ +var s = obj.method1(0); +>s : string +>obj.method1(0) : number +>obj.method1 : (arg0: number) => number +>obj : { [x: string]: any; bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; } +>method1 : (arg0: number) => number +>0 : 0 + +/** @type {string} */ +var s1 = obj.method2("0"); +>s1 : string +>obj.method2("0") : number +>obj.method2 : (arg0: number) => number +>obj : { [x: string]: any; bar: string | undefined; method1(arg0: number): number; method2: (arg0: number) => number; arrowFunc: (arg0: number) => number; lol: string; } +>method2 : (arg0: number) => number +>"0" : "0" + diff --git a/tests/baselines/reference/checkJsxChildrenProperty13.symbols b/tests/baselines/reference/checkJsxChildrenProperty13.symbols new file mode 100644 index 00000000000..24bf8a2162a --- /dev/null +++ b/tests/baselines/reference/checkJsxChildrenProperty13.symbols @@ -0,0 +1,68 @@ +=== tests/cases/conformance/jsx/file.tsx === +import React = require('react'); +>React : Symbol(React, Decl(file.tsx, 0, 0)) + +interface ButtonProp { +>ButtonProp : Symbol(ButtonProp, Decl(file.tsx, 0, 32)) + + a: number, +>a : Symbol(ButtonProp.a, Decl(file.tsx, 2, 22)) + + b: string, +>b : Symbol(ButtonProp.b, Decl(file.tsx, 3, 14)) + + children: Button; +>children : Symbol(ButtonProp.children, Decl(file.tsx, 4, 14)) +>Button : Symbol(Button, Decl(file.tsx, 6, 1)) +} + +class Button extends React.Component { +>Button : Symbol(Button, Decl(file.tsx, 6, 1)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) +>React : Symbol(React, Decl(file.tsx, 0, 0)) +>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) +>ButtonProp : Symbol(ButtonProp, Decl(file.tsx, 0, 32)) + + render() { +>render : Symbol(Button.render, Decl(file.tsx, 8, 55)) + + // Error children are specified twice + return ( +>InnerButton : Symbol(InnerButton, Decl(file.tsx, 19, 1)) +>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37)) +>this : Symbol(Button, Decl(file.tsx, 6, 1)) +>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37)) +>children : Symbol(children, Decl(file.tsx, 11, 44)) + +
Hello World
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + + ); +>InnerButton : Symbol(InnerButton, Decl(file.tsx, 19, 1)) + } +} + +interface InnerButtonProp { +>InnerButtonProp : Symbol(InnerButtonProp, Decl(file.tsx, 15, 1)) + + a: number +>a : Symbol(InnerButtonProp.a, Decl(file.tsx, 17, 27)) +} + +class InnerButton extends React.Component { +>InnerButton : Symbol(InnerButton, Decl(file.tsx, 19, 1)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) +>React : Symbol(React, Decl(file.tsx, 0, 0)) +>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) +>InnerButtonProp : Symbol(InnerButtonProp, Decl(file.tsx, 15, 1)) + + render() { +>render : Symbol(InnerButton.render, Decl(file.tsx, 21, 65)) + + return (); +>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43)) +>button : Symbol(JSX.IntrinsicElements.button, Decl(react.d.ts, 2386, 43)) + } +} + diff --git a/tests/baselines/reference/checkJsxChildrenProperty13.types b/tests/baselines/reference/checkJsxChildrenProperty13.types new file mode 100644 index 00000000000..10d3876ae63 --- /dev/null +++ b/tests/baselines/reference/checkJsxChildrenProperty13.types @@ -0,0 +1,73 @@ +=== tests/cases/conformance/jsx/file.tsx === +import React = require('react'); +>React : typeof React + +interface ButtonProp { +>ButtonProp : ButtonProp + + a: number, +>a : number + + b: string, +>b : string + + children: Button; +>children : Button +>Button : Button +} + +class Button extends React.Component { +>Button : Button +>React.Component : React.Component +>React : typeof React +>Component : typeof React.Component +>ButtonProp : ButtonProp + + render() { +>render : () => JSX.Element + + // Error children are specified twice + return ( +>(
Hello World
) : JSX.Element +>
Hello World
 : JSX.Element +>InnerButton : typeof InnerButton +>this.props : ButtonProp & { children?: React.ReactNode; } +>this : this +>props : ButtonProp & { children?: React.ReactNode; } +>children : string + +
Hello World
+>
Hello World
: JSX.Element +>div : any +>div : any + + ); +>InnerButton : typeof InnerButton + } +} + +interface InnerButtonProp { +>InnerButtonProp : InnerButtonProp + + a: number +>a : number +} + +class InnerButton extends React.Component { +>InnerButton : InnerButton +>React.Component : React.Component +>React : typeof React +>Component : typeof React.Component +>InnerButtonProp : InnerButtonProp + + render() { +>render : () => JSX.Element + + return (); +>() : JSX.Element +> : JSX.Element +>button : any +>button : any + } +} + diff --git a/tests/baselines/reference/checkJsxChildrenProperty2.symbols b/tests/baselines/reference/checkJsxChildrenProperty2.symbols new file mode 100644 index 00000000000..882c83b177a --- /dev/null +++ b/tests/baselines/reference/checkJsxChildrenProperty2.symbols @@ -0,0 +1,144 @@ +=== tests/cases/conformance/jsx/file.tsx === +import React = require('react'); +>React : Symbol(React, Decl(file.tsx, 0, 0)) + +interface Prop { +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) + + a: number, +>a : Symbol(Prop.a, Decl(file.tsx, 2, 16)) + + b: string, +>b : Symbol(Prop.b, Decl(file.tsx, 3, 14)) + + children: string | JSX.Element +>children : Symbol(Prop.children, Decl(file.tsx, 4, 14)) +>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1)) +>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27)) +} + +function Comp(p: Prop) { +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>p : Symbol(p, Decl(file.tsx, 8, 14)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) + + return
{p.b}
; +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>p.b : Symbol(Prop.b, Decl(file.tsx, 3, 14)) +>p : Symbol(p, Decl(file.tsx, 8, 14)) +>b : Symbol(Prop.b, Decl(file.tsx, 3, 14)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +} + +// Error: missing children +let k = ; +>k : Symbol(k, Decl(file.tsx, 13, 3)) +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>a : Symbol(a, Decl(file.tsx, 13, 13)) +>b : Symbol(b, Decl(file.tsx, 13, 20)) + +let k0 = +>k0 : Symbol(k0, Decl(file.tsx, 15, 3)) + + +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>a : Symbol(a, Decl(file.tsx, 16, 9)) +>b : Symbol(b, Decl(file.tsx, 16, 16)) +>children : Symbol(children, Decl(file.tsx, 16, 23)) + + hi hi hi! + ; +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) + +let o = { +>o : Symbol(o, Decl(file.tsx, 20, 3)) + + children:"Random" +>children : Symbol(children, Decl(file.tsx, 20, 9)) +} +let k1 = +>k1 : Symbol(k1, Decl(file.tsx, 23, 3)) + + +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>a : Symbol(a, Decl(file.tsx, 24, 9)) +>b : Symbol(b, Decl(file.tsx, 24, 16)) +>o : Symbol(o, Decl(file.tsx, 20, 3)) + + hi hi hi! + ; +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) + +// Error: incorrect type +let k2 = +>k2 : Symbol(k2, Decl(file.tsx, 29, 3)) + + +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>a : Symbol(a, Decl(file.tsx, 30, 9)) +>b : Symbol(b, Decl(file.tsx, 30, 16)) + +
My Div
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + + {(name: string) =>
My name {name}
} +>name : Symbol(name, Decl(file.tsx, 32, 10)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>name : Symbol(name, Decl(file.tsx, 32, 10)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + + ; +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) + +let k3 = +>k3 : Symbol(k3, Decl(file.tsx, 35, 3)) + + +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>a : Symbol(a, Decl(file.tsx, 36, 9)) +>b : Symbol(b, Decl(file.tsx, 36, 16)) + +
My Div
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + + {1000000} + ; +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) + +let k4 = +>k4 : Symbol(k4, Decl(file.tsx, 41, 3)) + + +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>a : Symbol(a, Decl(file.tsx, 42, 9)) +>b : Symbol(b, Decl(file.tsx, 42, 16)) + +
My Div
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + + hi hi hi! + ; +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) + +let k5 = +>k5 : Symbol(k5, Decl(file.tsx, 47, 3)) + + +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) +>a : Symbol(a, Decl(file.tsx, 48, 9)) +>b : Symbol(b, Decl(file.tsx, 48, 16)) + +
My Div
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + +
My Div
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + + ; +>Comp : Symbol(Comp, Decl(file.tsx, 6, 1)) + diff --git a/tests/baselines/reference/checkJsxChildrenProperty2.types b/tests/baselines/reference/checkJsxChildrenProperty2.types new file mode 100644 index 00000000000..2817c1709bd --- /dev/null +++ b/tests/baselines/reference/checkJsxChildrenProperty2.types @@ -0,0 +1,170 @@ +=== tests/cases/conformance/jsx/file.tsx === +import React = require('react'); +>React : typeof React + +interface Prop { +>Prop : Prop + + a: number, +>a : number + + b: string, +>b : string + + children: string | JSX.Element +>children : string | JSX.Element +>JSX : any +>Element : JSX.Element +} + +function Comp(p: Prop) { +>Comp : (p: Prop) => JSX.Element +>p : Prop +>Prop : Prop + + return
{p.b}
; +>
{p.b}
: JSX.Element +>div : any +>p.b : string +>p : Prop +>b : string +>div : any +} + +// Error: missing children +let k = ; +>k : JSX.Element +> : JSX.Element +>Comp : (p: Prop) => JSX.Element +>a : number +>10 : 10 +>b : string + +let k0 = +>k0 : JSX.Element + + +> hi hi hi! : JSX.Element +>Comp : (p: Prop) => JSX.Element +>a : number +>10 : 10 +>b : string +>children : string + + hi hi hi! + ; +>Comp : (p: Prop) => JSX.Element + +let o = { +>o : { children: string; } +>{ children:"Random"} : { children: string; } + + children:"Random" +>children : string +>"Random" : "Random" +} +let k1 = +>k1 : JSX.Element + + +> hi hi hi! : JSX.Element +>Comp : (p: Prop) => JSX.Element +>a : number +>10 : 10 +>b : string +>o : { children: string; } + + hi hi hi! + ; +>Comp : (p: Prop) => JSX.Element + +// Error: incorrect type +let k2 = +>k2 : JSX.Element + + +>
My Div
{(name: string) =>
My name {name}
} : JSX.Element +>Comp : (p: Prop) => JSX.Element +>a : number +>10 : 10 +>b : string + +
My Div
+>
My Div
: JSX.Element +>div : any +>div : any + + {(name: string) =>
My name {name}
} +>(name: string) =>
My name {name}
: (name: string) => JSX.Element +>name : string +>
My name {name}
: JSX.Element +>div : any +>name : string +>div : any + + ; +>Comp : (p: Prop) => JSX.Element + +let k3 = +>k3 : JSX.Element + + +>
My Div
{1000000} : JSX.Element +>Comp : (p: Prop) => JSX.Element +>a : number +>10 : 10 +>b : string + +
My Div
+>
My Div
: JSX.Element +>div : any +>div : any + + {1000000} +>1000000 : 1000000 + + ; +>Comp : (p: Prop) => JSX.Element + +let k4 = +>k4 : JSX.Element + + +>
My Div
hi hi hi! : JSX.Element +>Comp : (p: Prop) => JSX.Element +>a : number +>10 : 10 +>b : string + +
My Div
+>
My Div
: JSX.Element +>div : any +>div : any + + hi hi hi! + ; +>Comp : (p: Prop) => JSX.Element + +let k5 = +>k5 : JSX.Element + + +>
My Div
My Div
: JSX.Element +>Comp : (p: Prop) => JSX.Element +>a : number +>10 : 10 +>b : string + +
My Div
+>
My Div
: JSX.Element +>div : any +>div : any + +
My Div
+>
My Div
: JSX.Element +>div : any +>div : any + + ; +>Comp : (p: Prop) => JSX.Element + diff --git a/tests/baselines/reference/checkJsxChildrenProperty4.symbols b/tests/baselines/reference/checkJsxChildrenProperty4.symbols new file mode 100644 index 00000000000..6372113ea62 --- /dev/null +++ b/tests/baselines/reference/checkJsxChildrenProperty4.symbols @@ -0,0 +1,110 @@ +=== tests/cases/conformance/jsx/file.tsx === +import React = require('react'); +>React : Symbol(React, Decl(file.tsx, 0, 0)) + +interface IUser { +>IUser : Symbol(IUser, Decl(file.tsx, 0, 32)) + + Name: string; +>Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17)) +} + +interface IFetchUserProps { +>IFetchUserProps : Symbol(IFetchUserProps, Decl(file.tsx, 4, 1)) + + children: (user: IUser) => JSX.Element; +>children : Symbol(IFetchUserProps.children, Decl(file.tsx, 6, 27)) +>user : Symbol(user, Decl(file.tsx, 7, 15)) +>IUser : Symbol(IUser, Decl(file.tsx, 0, 32)) +>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1)) +>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27)) +} + +class FetchUser extends React.Component { +>FetchUser : Symbol(FetchUser, Decl(file.tsx, 8, 1)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) +>React : Symbol(React, Decl(file.tsx, 0, 0)) +>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) +>IFetchUserProps : Symbol(IFetchUserProps, Decl(file.tsx, 4, 1)) + + render() { +>render : Symbol(FetchUser.render, Decl(file.tsx, 10, 63)) + + return this.state +>this.state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44)) +>this : Symbol(FetchUser, Decl(file.tsx, 8, 1)) +>state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44)) + + ? this.props.children(this.state.result) +>this.props.children : Symbol(children, Decl(file.tsx, 6, 27), Decl(react.d.ts, 174, 20)) +>this.props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37)) +>this : Symbol(FetchUser, Decl(file.tsx, 8, 1)) +>props : Symbol(React.Component.props, Decl(react.d.ts, 167, 37)) +>children : Symbol(children, Decl(file.tsx, 6, 27), Decl(react.d.ts, 174, 20)) +>this.state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44)) +>this : Symbol(FetchUser, Decl(file.tsx, 8, 1)) +>state : Symbol(React.Component.state, Decl(react.d.ts, 174, 44)) + + : null; + } +} + +// Error +function UserName() { +>UserName : Symbol(UserName, Decl(file.tsx, 16, 1)) + + return ( + +>FetchUser : Symbol(FetchUser, Decl(file.tsx, 8, 1)) + + { user => ( +>user : Symbol(user, Decl(file.tsx, 22, 13)) + +

{ user.NAme }

+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47)) +>user : Symbol(user, Decl(file.tsx, 22, 13)) +>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47)) + + ) } + +>FetchUser : Symbol(FetchUser, Decl(file.tsx, 8, 1)) + + ); +} + +function UserName1() { +>UserName1 : Symbol(UserName1, Decl(file.tsx, 27, 1)) + + return ( + +>FetchUser : Symbol(FetchUser, Decl(file.tsx, 8, 1)) + + + + { user => ( +>user : Symbol(user, Decl(file.tsx, 35, 13)) + +

{ user.Name }

+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47)) +>user.Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17)) +>user : Symbol(user, Decl(file.tsx, 35, 13)) +>Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17)) +>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47)) + + ) } + { user => ( +>user : Symbol(user, Decl(file.tsx, 38, 13)) + +

{ user.Name }

+>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47)) +>user.Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17)) +>user : Symbol(user, Decl(file.tsx, 38, 13)) +>Name : Symbol(IUser.Name, Decl(file.tsx, 2, 17)) +>h1 : Symbol(JSX.IntrinsicElements.h1, Decl(react.d.ts, 2410, 47)) + + ) } + +>FetchUser : Symbol(FetchUser, Decl(file.tsx, 8, 1)) + + ); +} diff --git a/tests/baselines/reference/checkJsxChildrenProperty4.types b/tests/baselines/reference/checkJsxChildrenProperty4.types new file mode 100644 index 00000000000..6e4c04aa231 --- /dev/null +++ b/tests/baselines/reference/checkJsxChildrenProperty4.types @@ -0,0 +1,132 @@ +=== tests/cases/conformance/jsx/file.tsx === +import React = require('react'); +>React : typeof React + +interface IUser { +>IUser : IUser + + Name: string; +>Name : string +} + +interface IFetchUserProps { +>IFetchUserProps : IFetchUserProps + + children: (user: IUser) => JSX.Element; +>children : (user: IUser) => JSX.Element +>user : IUser +>IUser : IUser +>JSX : any +>Element : JSX.Element +} + +class FetchUser extends React.Component { +>FetchUser : FetchUser +>React.Component : React.Component +>React : typeof React +>Component : typeof React.Component +>IFetchUserProps : IFetchUserProps + + render() { +>render : () => JSX.Element + + return this.state +>this.state ? this.props.children(this.state.result) : null : JSX.Element +>this.state : any +>this : this +>state : any + + ? this.props.children(this.state.result) +>this.props.children(this.state.result) : JSX.Element +>this.props.children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) +>this.props : IFetchUserProps & { children?: React.ReactNode; } +>this : this +>props : IFetchUserProps & { children?: React.ReactNode; } +>children : ((user: IUser) => JSX.Element) | (((user: IUser) => JSX.Element) & string) | (((user: IUser) => JSX.Element) & number) | (((user: IUser) => JSX.Element) & true) | (((user: IUser) => JSX.Element) & false) | (((user: IUser) => JSX.Element) & React.ReactElement) | (((user: IUser) => JSX.Element) & (string | number | boolean | any[] | React.ReactElement)[]) +>this.state.result : any +>this.state : any +>this : this +>state : any +>result : any + + : null; +>null : null + } +} + +// Error +function UserName() { +>UserName : () => JSX.Element + + return ( +>( { user => (

{ user.NAme }

) } ) : JSX.Element + + +> { user => (

{ user.NAme }

) } : JSX.Element +>FetchUser : typeof FetchUser + + { user => ( +>user => (

{ user.NAme }

) : (user: IUser) => JSX.Element +>user : IUser +>(

{ user.NAme }

) : JSX.Element + +

{ user.NAme }

+>

{ user.NAme }

: JSX.Element +>h1 : any +>user.NAme : any +>user : IUser +>NAme : any +>h1 : any + + ) } + +>FetchUser : typeof FetchUser + + ); +} + +function UserName1() { +>UserName1 : () => JSX.Element + + return ( +>( { user => (

{ user.Name }

) } { user => (

{ user.Name }

) } ) : JSX.Element + + +> { user => (

{ user.Name }

) } { user => (

{ user.Name }

) } : JSX.Element +>FetchUser : typeof FetchUser + + + + { user => ( +>user => (

{ user.Name }

) : (user: IUser) => JSX.Element +>user : IUser +>(

{ user.Name }

) : JSX.Element + +

{ user.Name }

+>

{ user.Name }

: JSX.Element +>h1 : any +>user.Name : string +>user : IUser +>Name : string +>h1 : any + + ) } + { user => ( +>user => (

{ user.Name }

) : (user: IUser) => JSX.Element +>user : IUser +>(

{ user.Name }

) : JSX.Element + +

{ user.Name }

+>

{ user.Name }

: JSX.Element +>h1 : any +>user.Name : string +>user : IUser +>Name : string +>h1 : any + + ) } + +>FetchUser : typeof FetchUser + + ); +} diff --git a/tests/baselines/reference/checkJsxChildrenProperty5.symbols b/tests/baselines/reference/checkJsxChildrenProperty5.symbols new file mode 100644 index 00000000000..aa925f3f1b7 --- /dev/null +++ b/tests/baselines/reference/checkJsxChildrenProperty5.symbols @@ -0,0 +1,82 @@ +=== tests/cases/conformance/jsx/file.tsx === +import React = require('react'); +>React : Symbol(React, Decl(file.tsx, 0, 0)) + +interface Prop { +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) + + a: number, +>a : Symbol(Prop.a, Decl(file.tsx, 2, 16)) + + b: string, +>b : Symbol(Prop.b, Decl(file.tsx, 3, 14)) + + children: Button; +>children : Symbol(Prop.children, Decl(file.tsx, 4, 14)) +>Button : Symbol(Button, Decl(file.tsx, 6, 1)) +} + +class Button extends React.Component { +>Button : Symbol(Button, Decl(file.tsx, 6, 1)) +>React.Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) +>React : Symbol(React, Decl(file.tsx, 0, 0)) +>Component : Symbol(React.Component, Decl(react.d.ts, 158, 55), Decl(react.d.ts, 161, 66)) + + render() { +>render : Symbol(Button.render, Decl(file.tsx, 8, 48)) + + return (
My Button
) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) + } +} + +function Comp(p: Prop) { +>Comp : Symbol(Comp, Decl(file.tsx, 12, 1)) +>p : Symbol(p, Decl(file.tsx, 14, 14)) +>Prop : Symbol(Prop, Decl(file.tsx, 0, 32)) + + return
{p.b}
; +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +>p.b : Symbol(Prop.b, Decl(file.tsx, 3, 14)) +>p : Symbol(p, Decl(file.tsx, 14, 14)) +>b : Symbol(Prop.b, Decl(file.tsx, 3, 14)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45)) +} + +// Error: no children specified +let k = ; +>k : Symbol(k, Decl(file.tsx, 19, 3)) +>Comp : Symbol(Comp, Decl(file.tsx, 12, 1)) +>a : Symbol(a, Decl(file.tsx, 19, 13)) +>b : Symbol(b, Decl(file.tsx, 19, 20)) + +// Error: JSX.element is not the same as JSX.ElementClass +let k1 = +>k1 : Symbol(k1, Decl(file.tsx, 22, 3)) + + +>Comp : Symbol(Comp, Decl(file.tsx, 12, 1)) +>a : Symbol(a, Decl(file.tsx, 23, 9)) +>b : Symbol(b, Decl(file.tsx, 23, 16)) + +