microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-15 03:23:08 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Merge branch 'master' into reducedUnionTypes

Browse Source
This commit is contained in:
unknown 2015-04-14 14:03:05 -07:00
commit 7393898076
2507 changed files with 94723 additions and 85845 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
scripts/processDiagnosticMessages.ts
View File

@ -54,6 +54,7 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap:
var result =
'// <auto-generated />\r\n' +
'/// <reference path="types.ts" />\r\n' +
'/* @internal */\r\n' +
'module ts {\r\n' +
' export var Diagnostics = {\r\n';
var names = Utilities.getObjectKeys(messageTable);

5
src/compiler/checker.ts
View File

@ -9424,7 +9424,10 @@ module ts {
}
if (isArrayLikeType(inputType)) {
return getIndexTypeOfType(inputType, IndexKind.Number);
let indexType = getIndexTypeOfType(inputType, IndexKind.Number);
if (indexType) {
return indexType;
}
}
error(errorNode, Diagnostics.Type_0_is_not_an_array_type, typeToString(inputType));

8
src/compiler/diagnosticMessages.json
View File

@ -2043,19 +2043,19 @@
},
"'import ... =' can only be used in a .ts file.": {
"category": "Error",
"code": 8002
"code": 8002
},
"'export=' can only be used in a .ts file.": {
"category": "Error",
"code": 8003
"code": 8003
},
"'type parameter declarations' can only be used in a .ts file.": {
"category": "Error",
"code": 8004
"code": 8004
},
"'implements clauses' can only be used in a .ts file.": {
"category": "Error",
"code": 8005
"code": 8005
},
"'interface declarations' can only be used in a .ts file.": {
"category": "Error",

102
src/harness/typeWriter.ts
View File

@ -1,6 +1,5 @@
interface TypeWriterResult {
line: number;
column: number;
syntaxKind: number;
sourceText: string;
type: string;
@ -29,90 +28,43 @@ class TypeWriterWalker {
}
private visitNode(node: ts.Node): void {
switch (node.kind) {
// Should always log expressions that are not tokens
// Also, always log the "this" keyword
// TODO: Ideally we should log all expressions, but to compare to the
// old typeWriter baselines, suppress tokens
case ts.SyntaxKind.ThisKeyword:
case ts.SyntaxKind.SuperKeyword:
case ts.SyntaxKind.ArrayLiteralExpression:
case ts.SyntaxKind.ObjectLiteralExpression:
case ts.SyntaxKind.ElementAccessExpression:
case ts.SyntaxKind.CallExpression:
case ts.SyntaxKind.NewExpression:
case ts.SyntaxKind.TypeAssertionExpression:
case ts.SyntaxKind.ParenthesizedExpression:
case ts.SyntaxKind.FunctionExpression:
case ts.SyntaxKind.ArrowFunction:
case ts.SyntaxKind.TypeOfExpression:
case ts.SyntaxKind.VoidExpression:
case ts.SyntaxKind.DeleteExpression:
case ts.SyntaxKind.PrefixUnaryExpression:
case ts.SyntaxKind.PostfixUnaryExpression:
case ts.SyntaxKind.BinaryExpression:
case ts.SyntaxKind.ConditionalExpression:
case ts.SyntaxKind.SpreadElementExpression:
this.log(node, this.getTypeOfNode(node));
break;
case ts.SyntaxKind.PropertyAccessExpression:
for (var current = node; current.kind === ts.SyntaxKind.PropertyAccessExpression; current = current.parent) {
}
if (current.kind !== ts.SyntaxKind.HeritageClauseElement) {
this.log(node, this.getTypeOfNode(node));
}
break;
// Should not change expression status (maybe expressions)
// TODO: Again, ideally should log number and string literals too,
// but to be consistent with the old typeWriter, just log identifiers
case ts.SyntaxKind.Identifier:
var identifier = <ts.Identifier>node;
if (!this.isLabel(identifier)) {
var type = this.getTypeOfNode(identifier);
this.log(node, type);
}
break;
if (ts.isExpression(node) || node.kind === ts.SyntaxKind.Identifier) {
this.logTypeAndSymbol(node);
}
ts.forEachChild(node, child => this.visitNode(child));
}
private isLabel(identifier: ts.Identifier): boolean {
var parent = identifier.parent;
switch (parent.kind) {
case ts.SyntaxKind.ContinueStatement:
case ts.SyntaxKind.BreakStatement:
return (<ts.BreakOrContinueStatement>parent).label === identifier;
case ts.SyntaxKind.LabeledStatement:
return (<ts.LabeledStatement>parent).label === identifier;
}
return false;
}
private log(node: ts.Node, type: ts.Type): void {
private logTypeAndSymbol(node: ts.Node): void {
var actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
var lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
var sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
// If we got an unknown type, we temporarily want to fall back to just pretending the name
// (source text) of the node is the type. This is to align with the old typeWriter to make
// baseline comparisons easier. In the long term, we will want to just call typeToString
this.results.push({
line: lineAndCharacter.line,
// todo(cyrusn): Not sure why column is one-based for type-writer. But I'm preserving
// that behavior to prevent having a lot of baselines to fix up.
column: lineAndCharacter.character + 1,
syntaxKind: node.kind,
sourceText: sourceText,
type: this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.WriteOwnNameForAnyLike)
});
}
private getTypeOfNode(node: ts.Node): ts.Type {
var type = this.checker.getTypeAtLocation(node);
ts.Debug.assert(type !== undefined, "type doesn't exist");
return type;
var symbol = this.checker.getSymbolAtLocation(node);
var typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
if (symbol) {
var symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
if (symbol.declarations) {
for (let declaration of symbol.declarations) {
symbolString += ", ";
let declSourceFile = declaration.getSourceFile();
let declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
symbolString += `Decl(${ ts.getBaseFileName(declSourceFile.fileName) }, ${ declLineAndCharacter.line }, ${ declLineAndCharacter.character })`
}
}
symbolString += ")";
typeString += ", " + symbolString;
}
this.results.push({
line: lineAndCharacter.line,
syntaxKind: node.kind,
sourceText: sourceText,
type: typeString
});
}
}

114
src/server/session.ts
View File

@ -118,7 +118,7 @@ module ts.server {
constructor(private host: ServerHost, private logger: Logger) {
this.projectService =
new ProjectService(host, logger, (eventName, project, fileName) => {
new ProjectService(host, logger, (eventName,project,fileName) => {
this.handleEvent(eventName, project, fileName);
});
}
@ -263,7 +263,7 @@ module ts.server {
}
}
getDefinition({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.FileSpan[] {
getDefinition(line: number, offset: number, fileName: string): protocol.FileSpan[] {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
@ -285,7 +285,7 @@ module ts.server {
}));
}
getOccurrences({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.OccurrencesResponseItem[] {
getOccurrences(line: number, offset: number, fileName: string): protocol.OccurrencesResponseItem[] {
fileName = ts.normalizePath(fileName);
let project = this.projectService.getProjectForFile(fileName);
@ -315,7 +315,7 @@ module ts.server {
});
}
getRenameLocations({line, offset, file: fileName, findInComments, findInStrings }: protocol.RenameRequestArgs): protocol.RenameResponseBody {
getRenameLocations(line: number, offset: number, fileName: string,findInComments: boolean, findInStrings: boolean): protocol.RenameResponseBody {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
@ -383,7 +383,7 @@ module ts.server {
return { info: renameInfo, locs: bakedRenameLocs };
}
getReferences({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.ReferencesResponseBody {
getReferences(line: number, offset: number, fileName: string): protocol.ReferencesResponseBody {
// TODO: get all projects for this file; report refs for all projects deleting duplicates
// can avoid duplicates by eliminating same ref file from subsequent projects
var file = ts.normalizePath(fileName);
@ -430,12 +430,12 @@ module ts.server {
};
}
openClientFile({ file: fileName }: protocol.OpenRequestArgs) {
openClientFile(fileName: string) {
var file = ts.normalizePath(fileName);
this.projectService.openClientFile(file);
}
getQuickInfo({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.QuickInfoResponseBody {
getQuickInfo(line: number, offset: number, fileName: string): protocol.QuickInfoResponseBody {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
@ -461,7 +461,7 @@ module ts.server {
};
}
getFormattingEditsForRange({line, offset, endLine, endOffset, file: fileName}: protocol.FormatRequestArgs): protocol.CodeEdit[] {
getFormattingEditsForRange(line: number, offset: number, endLine: number, endOffset: number, fileName: string): protocol.CodeEdit[] {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
@ -488,7 +488,7 @@ module ts.server {
});
}
getFormattingEditsAfterKeystroke({line, offset, key, file: fileName}: protocol.FormatOnKeyRequestArgs): protocol.CodeEdit[] {
getFormattingEditsAfterKeystroke(line: number, offset: number, key: string, fileName: string): protocol.CodeEdit[] {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
@ -561,7 +561,7 @@ module ts.server {
});
}
getCompletions({ line, offset, prefix, file: fileName}: protocol.CompletionsRequestArgs): protocol.CompletionEntry[] {
getCompletions(line: number, offset: number, prefix: string, fileName: string): protocol.CompletionEntry[] {
if (!prefix) {
prefix = "";
}
@ -587,7 +587,8 @@ module ts.server {
}, []).sort((a, b) => a.name.localeCompare(b.name));
}
getCompletionEntryDetails({ line, offset, entryNames, file: fileName}: protocol.CompletionDetailsRequestArgs): protocol.CompletionEntryDetails[] {
getCompletionEntryDetails(line: number, offset: number,
entryNames: string[], fileName: string): protocol.CompletionEntryDetails[] {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
@ -606,20 +607,20 @@ module ts.server {
}, []);
}
getSignatureHelpItems({ line, offset, file: fileName }: protocol.SignatureHelpRequestArgs): protocol.SignatureHelpItems {
getSignatureHelpItems(line: number, offset: number, fileName: string): protocol.SignatureHelpItems {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
throw Errors.NoProject;
}
var compilerService = project.compilerService;
var position = compilerService.host.lineOffsetToPosition(file, line, offset);
var helpItems = compilerService.languageService.getSignatureHelpItems(file, position);
if (!helpItems) {
return undefined;
}
var span = helpItems.applicableSpan;
var result: protocol.SignatureHelpItems = {
items: helpItems.items,
@ -631,11 +632,11 @@ module ts.server {
argumentIndex: helpItems.argumentIndex,
argumentCount: helpItems.argumentCount,
}
return result;
}
getDiagnostics({ delay, files: fileNames }: protocol.GeterrRequestArgs): void {
getDiagnostics(delay: number, fileNames: string[]) {
var checkList = fileNames.reduce((accum: PendingErrorCheck[], fileName: string) => {
fileName = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(fileName);
@ -646,11 +647,11 @@ module ts.server {
}, []);
if (checkList.length > 0) {
this.updateErrorCheck(checkList, this.changeSeq, (n) => n == this.changeSeq, delay)
this.updateErrorCheck(checkList, this.changeSeq,(n) => n == this.changeSeq, delay)
}
}
change({ line, offset, endLine, endOffset, insertString, file: fileName }: protocol.ChangeRequestArgs): void {
change(line: number, offset: number, endLine: number, endOffset: number, insertString: string, fileName: string) {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (project) {
@ -665,7 +666,7 @@ module ts.server {
}
}
reload({ file: fileName, tmpfile: tempFileName }: protocol.ReloadRequestArgs, reqSeq = 0): void {
reload(fileName: string, tempFileName: string, reqSeq = 0) {
var file = ts.normalizePath(fileName);
var tmpfile = ts.normalizePath(tempFileName);
var project = this.projectService.getProjectForFile(file);
@ -678,7 +679,7 @@ module ts.server {
}
}
saveToTmp({ file: fileName, tmpfile: tempFileName }: protocol.SavetoRequestArgs): void {
saveToTmp(fileName: string, tempFileName: string) {
var file = ts.normalizePath(fileName);
var tmpfile = ts.normalizePath(tempFileName);
@ -688,7 +689,7 @@ module ts.server {
}
}
closeClientFile({ file: fileName }: protocol.FileRequestArgs) {
closeClientFile(fileName: string) {
var file = ts.normalizePath(fileName);
this.projectService.closeClientFile(file);
}
@ -712,7 +713,7 @@ module ts.server {
}));
}
getNavigationBarItems({ file: fileName }: protocol.FileRequestArgs): protocol.NavigationBarItem[]{
getNavigationBarItems(fileName: string): protocol.NavigationBarItem[] {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
@ -728,7 +729,7 @@ module ts.server {
return this.decorateNavigationBarItem(project, fileName, items);
}
getNavigateToItems({ searchValue, file: fileName, maxResultCount }: protocol.NavtoRequestArgs): protocol.NavtoItem[]{
getNavigateToItems(searchValue: string, fileName: string, maxResultCount?: number): protocol.NavtoItem[] {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
if (!project) {
@ -767,7 +768,7 @@ module ts.server {
});
}
getBraceMatching({ line, offset, file: fileName }: protocol.FileLocationRequestArgs): protocol.TextSpan[]{
getBraceMatching(line: number, offset: number, fileName: string): protocol.TextSpan[] {
var file = ts.normalizePath(fileName);
var project = this.projectService.getProjectForFile(file);
@ -809,91 +810,114 @@ module ts.server {
break;
}
case CommandNames.Definition: {
response = this.getDefinition(<protocol.FileLocationRequestArgs>request.arguments);
var defArgs = <protocol.FileLocationRequestArgs>request.arguments;
response = this.getDefinition(defArgs.line, defArgs.offset, defArgs.file);
break;
}
case CommandNames.References: {
response = this.getReferences(<protocol.FileLocationRequestArgs>request.arguments);
var refArgs = <protocol.FileLocationRequestArgs>request.arguments;
response = this.getReferences(refArgs.line, refArgs.offset, refArgs.file);
break;
}
case CommandNames.Rename: {
response = this.getRenameLocations(<protocol.RenameRequestArgs>request.arguments);
var renameArgs = <protocol.RenameRequestArgs>request.arguments;
response = this.getRenameLocations(renameArgs.line, renameArgs.offset, renameArgs.file, renameArgs.findInComments, renameArgs.findInStrings);
break;
}
case CommandNames.Open: {
this.openClientFile(<protocol.OpenRequestArgs>request.arguments);
var openArgs = <protocol.OpenRequestArgs>request.arguments;
this.openClientFile(openArgs.file);
responseRequired = false;
break;
}
case CommandNames.Quickinfo: {
response = this.getQuickInfo(<protocol.FileLocationRequestArgs>request.arguments);
var quickinfoArgs = <protocol.FileLocationRequestArgs>request.arguments;
response = this.getQuickInfo(quickinfoArgs.line, quickinfoArgs.offset, quickinfoArgs.file);
break;
}
case CommandNames.Format: {
response = this.getFormattingEditsForRange(<protocol.FormatRequestArgs>request.arguments);
var formatArgs = <protocol.FormatRequestArgs>request.arguments;
response = this.getFormattingEditsForRange(formatArgs.line, formatArgs.offset, formatArgs.endLine, formatArgs.endOffset, formatArgs.file);
break;
}
case CommandNames.Formatonkey: {
response = this.getFormattingEditsAfterKeystroke(<protocol.FormatOnKeyRequestArgs>request.arguments);
var formatOnKeyArgs = <protocol.FormatOnKeyRequestArgs>request.arguments;
response = this.getFormattingEditsAfterKeystroke(formatOnKeyArgs.line, formatOnKeyArgs.offset, formatOnKeyArgs.key, formatOnKeyArgs.file);
break;
}
case CommandNames.Completions: {
response = this.getCompletions(<protocol.CompletionsRequestArgs>request.arguments);
var completionsArgs = <protocol.CompletionsRequestArgs>request.arguments;
response = this.getCompletions(completionsArgs.line, completionsArgs.offset, completionsArgs.prefix, completionsArgs.file);
break;
}
case CommandNames.CompletionDetails: {
response = this.getCompletionEntryDetails(<protocol.CompletionDetailsRequestArgs>request.arguments);
var completionDetailsArgs = <protocol.CompletionDetailsRequestArgs>request.arguments;
response =
this.getCompletionEntryDetails(completionDetailsArgs.line,completionDetailsArgs.offset,
completionDetailsArgs.entryNames,completionDetailsArgs.file);
break;
}
case CommandNames.SignatureHelp: {
response = this.getSignatureHelpItems(<protocol.SignatureHelpRequestArgs>request.arguments);
var signatureHelpArgs = <protocol.SignatureHelpRequestArgs>request.arguments;
response = this.getSignatureHelpItems(signatureHelpArgs.line, signatureHelpArgs.offset, signatureHelpArgs.file);
break;
}
case CommandNames.Geterr: {
this.getDiagnostics(<protocol.GeterrRequestArgs>request.arguments);
var geterrArgs = <protocol.GeterrRequestArgs>request.arguments;
response = this.getDiagnostics(geterrArgs.delay, geterrArgs.files);
responseRequired = false;
break;
}
case CommandNames.Change: {
this.change(<protocol.ChangeRequestArgs>request.arguments);
var changeArgs = <protocol.ChangeRequestArgs>request.arguments;
this.change(changeArgs.line, changeArgs.offset, changeArgs.endLine, changeArgs.endOffset,
changeArgs.insertString, changeArgs.file);
responseRequired = false;
break;
}
case CommandNames.Configure: {
this.projectService.setHostConfiguration(<protocol.ConfigureRequestArguments>request.arguments);
var configureArgs = <protocol.ConfigureRequestArguments>request.arguments;
this.projectService.setHostConfiguration(configureArgs);
this.output(undefined, CommandNames.Configure, request.seq);
responseRequired = false;
break;
}
case CommandNames.Reload: {
this.reload(<protocol.ReloadRequestArgs>request.arguments);
var reloadArgs = <protocol.ReloadRequestArgs>request.arguments;
this.reload(reloadArgs.file, reloadArgs.tmpfile, request.seq);
responseRequired = false;
break;
}
case CommandNames.Saveto: {
this.saveToTmp(<protocol.SavetoRequestArgs>request.arguments);
var savetoArgs = <protocol.SavetoRequestArgs>request.arguments;
this.saveToTmp(savetoArgs.file, savetoArgs.tmpfile);
responseRequired = false;
break;
}
case CommandNames.Close: {
this.closeClientFile(<protocol.FileRequestArgs>request.arguments);
var closeArgs = <protocol.FileRequestArgs>request.arguments;
this.closeClientFile(closeArgs.file);
responseRequired = false;
break;
}
case CommandNames.Navto: {
response = this.getNavigateToItems(<protocol.NavtoRequestArgs>request.arguments);
var navtoArgs = <protocol.NavtoRequestArgs>request.arguments;
response = this.getNavigateToItems(navtoArgs.searchValue, navtoArgs.file, navtoArgs.maxResultCount);
break;
}
case CommandNames.Brace: {
response = this.getBraceMatching(<protocol.FileLocationRequestArgs>request.arguments);
var braceArguments = <protocol.FileLocationRequestArgs>request.arguments;
response = this.getBraceMatching(braceArguments.line, braceArguments.offset, braceArguments.file);
break;
}
case CommandNames.NavBar: {
response = this.getNavigationBarItems(<protocol.FileRequestArgs>request.arguments);
var navBarArgs = <protocol.FileRequestArgs>request.arguments;
response = this.getNavigationBarItems(navBarArgs.file);
break;
}
case CommandNames.Occurrences: {
response = this.getOccurrences(<protocol.FileLocationRequestArgs>request.arguments);
var { line, offset, file: fileName } = <protocol.FileLocationRequestArgs>request.arguments;
response = this.getOccurrences(line, offset, fileName);
break;
}
default: {

6
src/services/services.ts
View File

@ -3109,6 +3109,7 @@ module ts {
case SyntaxKind.SemicolonToken:
return containingNodeKind === SyntaxKind.PropertySignature &&
previousToken.parent && previousToken.parent.parent &&
(previousToken.parent.parent.kind === SyntaxKind.InterfaceDeclaration || // interface a { f; |
previousToken.parent.parent.kind === SyntaxKind.TypeLiteral); // let x : { a; |
@ -3124,7 +3125,8 @@ module ts {
case SyntaxKind.DotDotDotToken:
return containingNodeKind === SyntaxKind.Parameter ||
containingNodeKind === SyntaxKind.Constructor ||
(previousToken.parent.parent.kind === SyntaxKind.ArrayBindingPattern); // var [ ...z|
(previousToken.parent && previousToken.parent.parent &&
previousToken.parent.parent.kind === SyntaxKind.ArrayBindingPattern); // var [ ...z|
case SyntaxKind.PublicKeyword:
case SyntaxKind.PrivateKeyword:
@ -3987,7 +3989,7 @@ module ts {
// Get occurrences only supports reporting occurrences for the file queried. So
// filter down to that list.
results = filter(results, r => r.fileName === fileName);
results = filter(results, r => getCanonicalFileName(ts.normalizeSlashes(r.fileName)) === sourceFile);
}
return results;

36
tests/baselines/reference/2dArrays.types
View File

@ -1,40 +1,40 @@
=== tests/cases/compiler/2dArrays.ts ===
class Cell {
>Cell : Cell
>Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
}
class Ship {
>Ship : Ship
>Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
isSunk: boolean;
>isSunk : boolean
>isSunk : boolean, Symbol(isSunk, Decl(2dArrays.ts, 3, 12))
}
class Board {
>Board : Board
>Board : Board, Symbol(Board, Decl(2dArrays.ts, 5, 1))
ships: Ship[];
>ships : Ship[]
>Ship : Ship
>ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
>Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
cells: Cell[];
>cells : Cell[]
>Cell : Cell
>cells : Cell[], Symbol(cells, Decl(2dArrays.ts, 8, 18))
>Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
private allShipsSunk() {
>allShipsSunk : () => boolean
>allShipsSunk : () => boolean, Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
return this.ships.every(function (val) { return val.isSunk; });
>this.ships.every(function (val) { return val.isSunk; }) : boolean
>this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
>this.ships : Ship[]
>this : Board
>ships : Ship[]
>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
>this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
>this.ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
>this : Board, Symbol(Board, Decl(2dArrays.ts, 5, 1))
>ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean, Symbol(Array.every, Decl(lib.d.ts, 1094, 62))
>function (val) { return val.isSunk; } : (val: Ship) => boolean
>val : Ship
>val.isSunk : boolean
>val : Ship
>isSunk : boolean
>val : Ship, Symbol(val, Decl(2dArrays.ts, 12, 42))
>val.isSunk : boolean, Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
>val : Ship, Symbol(val, Decl(2dArrays.ts, 12, 42))
>isSunk : boolean, Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12))
}
}

176
tests/baselines/reference/APISample_compile.types
View File

@ -7,152 +7,162 @@
*/
declare var process: any;
>process : any
>process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
declare var console: any;
>console : any
>console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
declare var os: any;
>os : any
>os : any, Symbol(os, Decl(APISample_compile.ts, 9, 11))
import ts = require("typescript");
>ts : typeof ts
>ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
export function compile(fileNames: string[], options: ts.CompilerOptions): void {
>compile : (fileNames: string[], options: ts.CompilerOptions) => void
>fileNames : string[]
>options : ts.CompilerOptions
>ts : unknown
>CompilerOptions : ts.CompilerOptions
>compile : (fileNames: string[], options: ts.CompilerOptions) => void, Symbol(compile, Decl(APISample_compile.ts, 11, 34))
>fileNames : string[], Symbol(fileNames, Decl(APISample_compile.ts, 13, 24))
>options : ts.CompilerOptions, Symbol(options, Decl(APISample_compile.ts, 13, 44))
>ts : any, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
>CompilerOptions : ts.CompilerOptions, Symbol(ts.CompilerOptions, Decl(typescript.d.ts, 1074, 5))
var program = ts.createProgram(fileNames, options);
>program : ts.Program
>program : ts.Program, Symbol(program, Decl(APISample_compile.ts, 14, 7))
>ts.createProgram(fileNames, options) : ts.Program
>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program
>ts : typeof ts
>createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program
>fileNames : string[]
>options : ts.CompilerOptions
>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program, Symbol(ts.createProgram, Decl(typescript.d.ts, 1201, 113))
>ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
>createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program, Symbol(ts.createProgram, Decl(typescript.d.ts, 1201, 113))
>fileNames : string[], Symbol(fileNames, Decl(APISample_compile.ts, 13, 24))
>options : ts.CompilerOptions, Symbol(options, Decl(APISample_compile.ts, 13, 44))
var emitResult = program.emit();
>emitResult : ts.EmitResult
>emitResult : ts.EmitResult, Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
>program.emit() : ts.EmitResult
>program.emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
>program : ts.Program
>emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
>program.emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult, Symbol(ts.Program.emit, Decl(typescript.d.ts, 767, 39))
>program : ts.Program, Symbol(program, Decl(APISample_compile.ts, 14, 7))
>emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult, Symbol(ts.Program.emit, Decl(typescript.d.ts, 767, 39))
var allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
>allDiagnostics : ts.Diagnostic[]
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_compile.ts, 17, 7))
>ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics) : ts.Diagnostic[]
>ts.getPreEmitDiagnostics(program).concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>ts.getPreEmitDiagnostics(program).concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>ts.getPreEmitDiagnostics(program) : ts.Diagnostic[]
>ts.getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[]
>ts : typeof ts
>getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[]
>program : ts.Program
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>emitResult.diagnostics : ts.Diagnostic[]
>emitResult : ts.EmitResult
>diagnostics : ts.Diagnostic[]
>ts.getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[], Symbol(ts.getPreEmitDiagnostics, Decl(typescript.d.ts, 1199, 98))
>ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
>getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[], Symbol(ts.getPreEmitDiagnostics, Decl(typescript.d.ts, 1199, 98))
>program : ts.Program, Symbol(program, Decl(APISample_compile.ts, 14, 7))
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>emitResult.diagnostics : ts.Diagnostic[], Symbol(ts.EmitResult.diagnostics, Decl(typescript.d.ts, 820, 29))
>emitResult : ts.EmitResult, Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
>diagnostics : ts.Diagnostic[], Symbol(ts.EmitResult.diagnostics, Decl(typescript.d.ts, 820, 29))
allDiagnostics.forEach(diagnostic => {
>allDiagnostics.forEach(diagnostic => { var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'); console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); }) : void
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
>allDiagnostics : ts.Diagnostic[]
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_compile.ts, 17, 7))
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>diagnostic => { var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'); console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); } : (diagnostic: ts.Diagnostic) => void
>diagnostic : ts.Diagnostic
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
>line : number
>character : number
>line : number, Symbol(line, Decl(APISample_compile.ts, 20, 13))
>character : number, Symbol(character, Decl(APISample_compile.ts, 20, 19))
>diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>diagnostic.file : ts.SourceFile
>diagnostic : ts.Diagnostic
>file : ts.SourceFile
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>diagnostic.start : number
>diagnostic : ts.Diagnostic
>start : number
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1263, 46))
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
>file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1263, 46))
>diagnostic.start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
>start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
>message : string
>message : string, Symbol(message, Decl(APISample_compile.ts, 21, 11))
>ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n') : string
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
>ts : typeof ts
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
>diagnostic.messageText : string | ts.DiagnosticMessageChain
>diagnostic : ts.Diagnostic
>messageText : string | ts.DiagnosticMessageChain
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1200, 67))
>ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1200, 67))
>diagnostic.messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
>messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
>'\n' : string
console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
>console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
>log : any
>diagnostic.file.fileName : string
>diagnostic.file : ts.SourceFile
>diagnostic : ts.Diagnostic
>file : ts.SourceFile
>fileName : string
>`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}` : string
>diagnostic.file.fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
>file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
>line + 1 : number
>line : number
>line : number, Symbol(line, Decl(APISample_compile.ts, 20, 13))
>1 : number
>character + 1 : number
>character : number
>message : string
>character : number, Symbol(character, Decl(APISample_compile.ts, 20, 19))
>1 : number
>message : string, Symbol(message, Decl(APISample_compile.ts, 21, 11))
});
var exitCode = emitResult.emitSkipped ? 1 : 0;
>exitCode : number
>exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
>emitResult.emitSkipped ? 1 : 0 : number
>emitResult.emitSkipped : boolean
>emitResult : ts.EmitResult
>emitSkipped : boolean
>emitResult.emitSkipped : boolean, Symbol(ts.EmitResult.emitSkipped, Decl(typescript.d.ts, 819, 26))
>emitResult : ts.EmitResult, Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
>emitSkipped : boolean, Symbol(ts.EmitResult.emitSkipped, Decl(typescript.d.ts, 819, 26))
>1 : number
>0 : number
console.log(`Process exiting with code '${exitCode}'.`);
>console.log(`Process exiting with code '${exitCode}'.`) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
>log : any
>exitCode : number
>`Process exiting with code '${exitCode}'.` : string
>exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
process.exit(exitCode);
>process.exit(exitCode) : any
>process.exit : any
>process : any
>process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
>exit : any
>exitCode : number
>exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
}
compile(process.argv.slice(2), {
>compile(process.argv.slice(2), { noEmitOnError: true, noImplicitAny: true, target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS}) : void
>compile : (fileNames: string[], options: ts.CompilerOptions) => void
>compile : (fileNames: string[], options: ts.CompilerOptions) => void, Symbol(compile, Decl(APISample_compile.ts, 11, 34))
>process.argv.slice(2) : any
>process.argv.slice : any
>process.argv : any
>process : any
>process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
>argv : any
>slice : any
>2 : number
>{ noEmitOnError: true, noImplicitAny: true, target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS} : { [x: string]: boolean | ts.ScriptTarget | ts.ModuleKind; noEmitOnError: boolean; noImplicitAny: boolean; target: ts.ScriptTarget; module: ts.ModuleKind; }
noEmitOnError: true, noImplicitAny: true,
>noEmitOnError : boolean
>noImplicitAny : boolean
>noEmitOnError : boolean, Symbol(noEmitOnError, Decl(APISample_compile.ts, 30, 32))
>true : boolean
>noImplicitAny : boolean, Symbol(noImplicitAny, Decl(APISample_compile.ts, 31, 24))
>true : boolean
target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS
>target : ts.ScriptTarget
>ts.ScriptTarget.ES5 : ts.ScriptTarget
>ts.ScriptTarget : typeof ts.ScriptTarget
>ts : typeof ts
>ScriptTarget : typeof ts.ScriptTarget
>ES5 : ts.ScriptTarget
>module : ts.ModuleKind
>ts.ModuleKind.CommonJS : ts.ModuleKind
>ts.ModuleKind : typeof ts.ModuleKind
>ts : typeof ts
>ModuleKind : typeof ts.ModuleKind
>CommonJS : ts.ModuleKind
>target : ts.ScriptTarget, Symbol(target, Decl(APISample_compile.ts, 31, 45))
>ts.ScriptTarget.ES5 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES5, Decl(typescript.d.ts, 1117, 16))
>ts.ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
>ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
>ES5 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES5, Decl(typescript.d.ts, 1117, 16))
>module : ts.ModuleKind, Symbol(module, Decl(APISample_compile.ts, 32, 32))
>ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
>ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
>ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
>CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
});

351
tests/baselines/reference/APISample_linter.types
View File

@ -7,297 +7,306 @@
*/
declare var process: any;
>process : any
>process : any, Symbol(process, Decl(APISample_linter.ts, 7, 11))
declare var console: any;
>console : any
>console : any, Symbol(console, Decl(APISample_linter.ts, 8, 11))
declare var readFileSync: any;
>readFileSync : any
>readFileSync : any, Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
import * as ts from "typescript";
>ts : typeof ts
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
export function delint(sourceFile: ts.SourceFile) {
>delint : (sourceFile: ts.SourceFile) => void
>sourceFile : ts.SourceFile
>ts : unknown
>SourceFile : ts.SourceFile
>delint : (sourceFile: ts.SourceFile) => void, Symbol(delint, Decl(APISample_linter.ts, 11, 33))
>sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
>ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SourceFile : ts.SourceFile, Symbol(ts.SourceFile, Decl(typescript.d.ts, 740, 5), Decl(typescript.d.ts, 1261, 5))
delintNode(sourceFile);
>delintNode(sourceFile) : void
>delintNode : (node: ts.Node) => void
>sourceFile : ts.SourceFile
>delintNode : (node: ts.Node) => void, Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
>sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
function delintNode(node: ts.Node) {
>delintNode : (node: ts.Node) => void
>node : ts.Node
>ts : unknown
>Node : ts.Node
>delintNode : (node: ts.Node) => void, Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
>ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>Node : ts.Node, Symbol(ts.Node, Decl(typescript.d.ts, 296, 5), Decl(typescript.d.ts, 1221, 32))
switch (node.kind) {
>node.kind : ts.SyntaxKind
>node : ts.Node
>kind : ts.SyntaxKind
>node.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
>kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
case ts.SyntaxKind.ForStatement:
>ts.SyntaxKind.ForStatement : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>ForStatement : ts.SyntaxKind
>ts.SyntaxKind.ForStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForStatement, Decl(typescript.d.ts, 209, 29))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ForStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForStatement, Decl(typescript.d.ts, 209, 29))
case ts.SyntaxKind.ForInStatement:
>ts.SyntaxKind.ForInStatement : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>ForInStatement : ts.SyntaxKind
>ts.SyntaxKind.ForInStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForInStatement, Decl(typescript.d.ts, 210, 27))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ForInStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.ForInStatement, Decl(typescript.d.ts, 210, 27))
case ts.SyntaxKind.WhileStatement:
>ts.SyntaxKind.WhileStatement : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>WhileStatement : ts.SyntaxKind
>ts.SyntaxKind.WhileStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.WhileStatement, Decl(typescript.d.ts, 208, 26))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>WhileStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.WhileStatement, Decl(typescript.d.ts, 208, 26))
case ts.SyntaxKind.DoStatement:
>ts.SyntaxKind.DoStatement : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>DoStatement : ts.SyntaxKind
>ts.SyntaxKind.DoStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.DoStatement, Decl(typescript.d.ts, 207, 26))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>DoStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.DoStatement, Decl(typescript.d.ts, 207, 26))
if ((<ts.IterationStatement>node).statement.kind !== ts.SyntaxKind.Block) {
>(<ts.IterationStatement>node).statement.kind !== ts.SyntaxKind.Block : boolean
>(<ts.IterationStatement>node).statement.kind : ts.SyntaxKind
>(<ts.IterationStatement>node).statement : ts.Statement
>(<ts.IterationStatement>node).statement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>(<ts.IterationStatement>node).statement : ts.Statement, Symbol(ts.IterationStatement.statement, Decl(typescript.d.ts, 589, 52))
>(<ts.IterationStatement>node) : ts.IterationStatement
><ts.IterationStatement>node : ts.IterationStatement
>ts : unknown
>IterationStatement : ts.IterationStatement
>node : ts.Node
>statement : ts.Statement
>kind : ts.SyntaxKind
>ts.SyntaxKind.Block : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>Block : ts.SyntaxKind
>ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>IterationStatement : ts.IterationStatement, Symbol(ts.IterationStatement, Decl(typescript.d.ts, 588, 5))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
>statement : ts.Statement, Symbol(ts.IterationStatement.statement, Decl(typescript.d.ts, 589, 52))
>kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
report(node, "A looping statement's contents should be wrapped in a block body.");
>report(node, "A looping statement's contents should be wrapped in a block body.") : void
>report : (node: ts.Node, message: string) => void
>node : ts.Node
>report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
>"A looping statement's contents should be wrapped in a block body." : string
}
break;
case ts.SyntaxKind.IfStatement:
>ts.SyntaxKind.IfStatement : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>IfStatement : ts.SyntaxKind
>ts.SyntaxKind.IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
let ifStatement = (<ts.IfStatement>node);
>ifStatement : ts.IfStatement
>ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
>(<ts.IfStatement>node) : ts.IfStatement
><ts.IfStatement>node : ts.IfStatement
>ts : unknown
>IfStatement : ts.IfStatement
>node : ts.Node
>ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>IfStatement : ts.IfStatement, Symbol(ts.IfStatement, Decl(typescript.d.ts, 583, 5))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) {
>ifStatement.thenStatement.kind !== ts.SyntaxKind.Block : boolean
>ifStatement.thenStatement.kind : ts.SyntaxKind
>ifStatement.thenStatement : ts.Statement
>ifStatement : ts.IfStatement
>thenStatement : ts.Statement
>kind : ts.SyntaxKind
>ts.SyntaxKind.Block : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>Block : ts.SyntaxKind
>ifStatement.thenStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>ifStatement.thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
>ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
>thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
>kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
>report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.") : void
>report : (node: ts.Node, message: string) => void
>ifStatement.thenStatement : ts.Statement
>ifStatement : ts.IfStatement
>thenStatement : ts.Statement
>report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
>ifStatement.thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
>ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
>thenStatement : ts.Statement, Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
>"An if statement's contents should be wrapped in a block body." : string
}
if (ifStatement.elseStatement &&
>ifStatement.elseStatement && ifStatement.elseStatement.kind !== ts.SyntaxKind.Block && ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement : boolean
>ifStatement.elseStatement && ifStatement.elseStatement.kind !== ts.SyntaxKind.Block : boolean
>ifStatement.elseStatement : ts.Statement
>ifStatement : ts.IfStatement
>elseStatement : ts.Statement
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
>ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
ifStatement.elseStatement.kind !== ts.SyntaxKind.Block &&
>ifStatement.elseStatement.kind !== ts.SyntaxKind.Block : boolean
>ifStatement.elseStatement.kind : ts.SyntaxKind
>ifStatement.elseStatement : ts.Statement
>ifStatement : ts.IfStatement
>elseStatement : ts.Statement
>kind : ts.SyntaxKind
>ts.SyntaxKind.Block : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>Block : ts.SyntaxKind
>ifStatement.elseStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
>ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
>kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>ts.SyntaxKind.Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>Block : ts.SyntaxKind, Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) {
>ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement : boolean
>ifStatement.elseStatement.kind : ts.SyntaxKind
>ifStatement.elseStatement : ts.Statement
>ifStatement : ts.IfStatement
>elseStatement : ts.Statement
>kind : ts.SyntaxKind
>ts.SyntaxKind.IfStatement : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>IfStatement : ts.SyntaxKind
>ifStatement.elseStatement.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
>ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
>kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>ts.SyntaxKind.IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>IfStatement : ts.SyntaxKind, Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
>report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.") : void
>report : (node: ts.Node, message: string) => void
>ifStatement.elseStatement : ts.Statement
>ifStatement : ts.IfStatement
>elseStatement : ts.Statement
>report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
>ifStatement.elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
>ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
>elseStatement : ts.Statement, Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
>"An else statement's contents should be wrapped in a block body." : string
}
break;
case ts.SyntaxKind.BinaryExpression:
>ts.SyntaxKind.BinaryExpression : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>BinaryExpression : ts.SyntaxKind
>ts.SyntaxKind.BinaryExpression : ts.SyntaxKind, Symbol(ts.SyntaxKind.BinaryExpression, Decl(typescript.d.ts, 192, 37))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>BinaryExpression : ts.SyntaxKind, Symbol(ts.SyntaxKind.BinaryExpression, Decl(typescript.d.ts, 192, 37))
let op = (<ts.BinaryExpression>node).operatorToken.kind;
>op : ts.SyntaxKind
>(<ts.BinaryExpression>node).operatorToken.kind : ts.SyntaxKind
>(<ts.BinaryExpression>node).operatorToken : ts.Node
>op : ts.SyntaxKind, Symbol(op, Decl(APISample_linter.ts, 40, 19))
>(<ts.BinaryExpression>node).operatorToken.kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
>(<ts.BinaryExpression>node).operatorToken : ts.Node, Symbol(ts.BinaryExpression.operatorToken, Decl(typescript.d.ts, 497, 25))
>(<ts.BinaryExpression>node) : ts.BinaryExpression
><ts.BinaryExpression>node : ts.BinaryExpression
>ts : unknown
>BinaryExpression : ts.BinaryExpression
>node : ts.Node
>operatorToken : ts.Node
>kind : ts.SyntaxKind
>ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>BinaryExpression : ts.BinaryExpression, Symbol(ts.BinaryExpression, Decl(typescript.d.ts, 495, 5))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
>operatorToken : ts.Node, Symbol(ts.BinaryExpression.operatorToken, Decl(typescript.d.ts, 497, 25))
>kind : ts.SyntaxKind, Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) {
>op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken : boolean
>op === ts.SyntaxKind.EqualsEqualsToken : boolean
>op : ts.SyntaxKind
>ts.SyntaxKind.EqualsEqualsToken : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>EqualsEqualsToken : ts.SyntaxKind
>op : ts.SyntaxKind, Symbol(op, Decl(APISample_linter.ts, 40, 19))
>ts.SyntaxKind.EqualsEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.EqualsEqualsToken, Decl(typescript.d.ts, 51, 36))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>EqualsEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.EqualsEqualsToken, Decl(typescript.d.ts, 51, 36))
>op == ts.SyntaxKind.ExclamationEqualsToken : boolean
>op : ts.SyntaxKind
>ts.SyntaxKind.ExclamationEqualsToken : ts.SyntaxKind
>ts.SyntaxKind : typeof ts.SyntaxKind
>ts : typeof ts
>SyntaxKind : typeof ts.SyntaxKind
>ExclamationEqualsToken : ts.SyntaxKind
>op : ts.SyntaxKind, Symbol(op, Decl(APISample_linter.ts, 40, 19))
>ts.SyntaxKind.ExclamationEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.ExclamationEqualsToken, Decl(typescript.d.ts, 52, 31))
>ts.SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>SyntaxKind : typeof ts.SyntaxKind, Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
>ExclamationEqualsToken : ts.SyntaxKind, Symbol(ts.SyntaxKind.ExclamationEqualsToken, Decl(typescript.d.ts, 52, 31))
report(node, "Use '===' and '!=='.")
>report(node, "Use '===' and '!=='.") : void
>report : (node: ts.Node, message: string) => void
>node : ts.Node
>report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
>"Use '===' and '!=='." : string
}
break;
}
ts.forEachChild(node, delintNode);
>ts.forEachChild(node, delintNode) : void
>ts.forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T
>ts : typeof ts
>forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T
>node : ts.Node
>delintNode : (node: ts.Node) => void
>ts.forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T, Symbol(ts.forEachChild, Decl(typescript.d.ts, 1186, 48))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>forEachChild : <T>(node: ts.Node, cbNode: (node: ts.Node) => T, cbNodeArray?: (nodes: ts.Node[]) => T) => T, Symbol(ts.forEachChild, Decl(typescript.d.ts, 1186, 48))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
>delintNode : (node: ts.Node) => void, Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
}
function report(node: ts.Node, message: string) {
>report : (node: ts.Node, message: string) => void
>node : ts.Node
>ts : unknown
>Node : ts.Node
>message : string
>report : (node: ts.Node, message: string) => void, Symbol(report, Decl(APISample_linter.ts, 48, 5))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 50, 20))
>ts : any, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>Node : ts.Node, Symbol(ts.Node, Decl(typescript.d.ts, 296, 5), Decl(typescript.d.ts, 1221, 32))
>message : string, Symbol(message, Decl(APISample_linter.ts, 50, 34))
let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
>line : number
>character : number
>line : number, Symbol(line, Decl(APISample_linter.ts, 51, 13))
>character : number, Symbol(character, Decl(APISample_linter.ts, 51, 19))
>sourceFile.getLineAndCharacterOfPosition(node.getStart()) : ts.LineAndCharacter
>sourceFile.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>sourceFile : ts.SourceFile
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>sourceFile.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1263, 46))
>sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1263, 46))
>node.getStart() : number
>node.getStart : (sourceFile?: ts.SourceFile) => number
>node : ts.Node
>getStart : (sourceFile?: ts.SourceFile) => number
>node.getStart : (sourceFile?: ts.SourceFile) => number, Symbol(ts.Node.getStart, Decl(typescript.d.ts, 1226, 53))
>node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 50, 20))
>getStart : (sourceFile?: ts.SourceFile) => number, Symbol(ts.Node.getStart, Decl(typescript.d.ts, 1226, 53))
console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`);
>console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_linter.ts, 8, 11))
>log : any
>sourceFile.fileName : string
>sourceFile : ts.SourceFile
>fileName : string
>`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}` : string
>sourceFile.fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
>sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
>fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
>line + 1 : number
>line : number
>line : number, Symbol(line, Decl(APISample_linter.ts, 51, 13))
>1 : number
>character + 1 : number
>character : number
>message : string
>character : number, Symbol(character, Decl(APISample_linter.ts, 51, 19))
>1 : number
>message : string, Symbol(message, Decl(APISample_linter.ts, 50, 34))
}
}
const fileNames = process.argv.slice(2);
>fileNames : any
>fileNames : any, Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
>process.argv.slice(2) : any
>process.argv.slice : any
>process.argv : any
>process : any
>process : any, Symbol(process, Decl(APISample_linter.ts, 7, 11))
>argv : any
>slice : any
>2 : number
fileNames.forEach(fileName => {
>fileNames.forEach(fileName => { // Parse a file let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); // delint it delint(sourceFile);}) : any
>fileNames.forEach : any
>fileNames : any
>fileNames : any, Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
>forEach : any
>fileName => { // Parse a file let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true); // delint it delint(sourceFile);} : (fileName: any) => void
>fileName : any
>fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
// Parse a file
let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true);
>sourceFile : ts.SourceFile
>sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
>ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true) : ts.SourceFile
>ts.createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile
>ts : typeof ts
>createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile
>fileName : any
>ts.createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile, Symbol(ts.createSourceFile, Decl(typescript.d.ts, 1190, 62))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile, Symbol(ts.createSourceFile, Decl(typescript.d.ts, 1190, 62))
>fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
>readFileSync(fileName).toString() : any
>readFileSync(fileName).toString : any
>readFileSync(fileName) : any
>readFileSync : any
>fileName : any
>readFileSync : any, Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
>fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
>toString : any
>ts.ScriptTarget.ES6 : ts.ScriptTarget
>ts.ScriptTarget : typeof ts.ScriptTarget
>ts : typeof ts
>ScriptTarget : typeof ts.ScriptTarget
>ES6 : ts.ScriptTarget
>ts.ScriptTarget.ES6 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES6, Decl(typescript.d.ts, 1118, 16))
>ts.ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
>ScriptTarget : typeof ts.ScriptTarget, Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
>ES6 : ts.ScriptTarget, Symbol(ts.ScriptTarget.ES6, Decl(typescript.d.ts, 1118, 16))
>true : boolean
// delint it
delint(sourceFile);
>delint(sourceFile) : void
>delint : (sourceFile: ts.SourceFile) => void
>sourceFile : ts.SourceFile
>delint : (sourceFile: ts.SourceFile) => void, Symbol(delint, Decl(APISample_linter.ts, 11, 33))
>sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
});

39
tests/baselines/reference/APISample_transform.types
View File

@ -7,37 +7,38 @@
*/
declare var console: any;
>console : any
>console : any, Symbol(console, Decl(APISample_transform.ts, 7, 11))
import * as ts from "typescript";
>ts : typeof ts
>ts : typeof ts, Symbol(ts, Decl(APISample_transform.ts, 9, 6))
const source = "let x: string = 'string'";
>source : string
>source : string, Symbol(source, Decl(APISample_transform.ts, 11, 5))
>"let x: string = 'string'" : string
let result = ts.transpile(source, { module: ts.ModuleKind.CommonJS });
>result : string
>result : string, Symbol(result, Decl(APISample_transform.ts, 13, 3))
>ts.transpile(source, { module: ts.ModuleKind.CommonJS }) : string
>ts.transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string
>ts : typeof ts
>transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string
>source : string
>ts.transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string, Symbol(ts.transpile, Decl(typescript.d.ts, 1729, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_transform.ts, 9, 6))
>transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string, Symbol(ts.transpile, Decl(typescript.d.ts, 1729, 5))
>source : string, Symbol(source, Decl(APISample_transform.ts, 11, 5))
>{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: ts.ModuleKind; }
>module : ts.ModuleKind
>ts.ModuleKind.CommonJS : ts.ModuleKind
>ts.ModuleKind : typeof ts.ModuleKind
>ts : typeof ts
>ModuleKind : typeof ts.ModuleKind
>CommonJS : ts.ModuleKind
>module : ts.ModuleKind, Symbol(module, Decl(APISample_transform.ts, 13, 35))
>ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
>ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_transform.ts, 9, 6))
>ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
>CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
console.log(JSON.stringify(result));
>console.log(JSON.stringify(result)) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_transform.ts, 7, 11))
>log : any
>JSON.stringify(result) : string
>JSON.stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
>JSON : JSON
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
>result : string
>JSON.stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }, Symbol(JSON.stringify, Decl(lib.d.ts, 964, 70), Decl(lib.d.ts, 969, 34), Decl(lib.d.ts, 975, 78), Decl(lib.d.ts, 981, 51), Decl(lib.d.ts, 988, 90))
>JSON : JSON, Symbol(JSON, Decl(lib.d.ts, 955, 42), Decl(lib.d.ts, 1000, 11))
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }, Symbol(JSON.stringify, Decl(lib.d.ts, 964, 70), Decl(lib.d.ts, 969, 34), Decl(lib.d.ts, 975, 78), Decl(lib.d.ts, 981, 51), Decl(lib.d.ts, 988, 90))
>result : string, Symbol(result, Decl(APISample_transform.ts, 13, 3))

381
tests/baselines/reference/APISample_watcher.types
View File

@ -7,197 +7,200 @@
*/
declare var process: any;
>process : any
>process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
declare var console: any;
>console : any
>console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
declare var fs: any;
>fs : any
>fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
declare var path: any;
>path : any
>path : any, Symbol(path, Decl(APISample_watcher.ts, 10, 11))
import * as ts from "typescript";
>ts : typeof ts
>ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
function watch(rootFileNames: string[], options: ts.CompilerOptions) {
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void
>rootFileNames : string[]
>options : ts.CompilerOptions
>ts : unknown
>CompilerOptions : ts.CompilerOptions
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void, Symbol(watch, Decl(APISample_watcher.ts, 12, 33))
>rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
>options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 14, 39))
>ts : any, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>CompilerOptions : ts.CompilerOptions, Symbol(ts.CompilerOptions, Decl(typescript.d.ts, 1074, 5))
const files: ts.Map<{ version: number }> = {};
>files : ts.Map<{ version: number; }>
>ts : unknown
>Map : ts.Map<T>
>version : number
>files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
>ts : any, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>Map : ts.Map<T>, Symbol(ts.Map, Decl(typescript.d.ts, 15, 29))
>version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
>{} : { [x: string]: undefined; }
// initialize the list of files
rootFileNames.forEach(fileName => {
>rootFileNames.forEach(fileName => { files[fileName] = { version: 0 }; }) : void
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
>rootFileNames : string[]
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>fileName => { files[fileName] = { version: 0 }; } : (fileName: string) => void
>fileName : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
files[fileName] = { version: 0 };
>files[fileName] = { version: 0 } : { version: number; }
>files[fileName] : { version: number; }
>files : ts.Map<{ version: number; }>
>fileName : string
>files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
>{ version: 0 } : { version: number; }
>version : number
>version : number, Symbol(version, Decl(APISample_watcher.ts, 19, 27))
>0 : number
});
// Create the language service host to allow the LS to communicate with the host
const servicesHost: ts.LanguageServiceHost = {
>servicesHost : ts.LanguageServiceHost
>ts : unknown
>LanguageServiceHost : ts.LanguageServiceHost
>servicesHost : ts.LanguageServiceHost, Symbol(servicesHost, Decl(APISample_watcher.ts, 23, 9))
>ts : any, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>LanguageServiceHost : ts.LanguageServiceHost, Symbol(ts.LanguageServiceHost, Decl(typescript.d.ts, 1295, 5))
>{ getScriptFileNames: () => rootFileNames, getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(), getScriptSnapshot: (fileName) => { if (!fs.existsSync(fileName)) { return undefined; } return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString()); }, getCurrentDirectory: () => process.cwd(), getCompilationSettings: () => options, getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options), } : { getScriptFileNames: () => string[]; getScriptVersion: (fileName: string) => string; getScriptSnapshot: (fileName: string) => ts.IScriptSnapshot; getCurrentDirectory: () => any; getCompilationSettings: () => ts.CompilerOptions; getDefaultLibFileName: (options: ts.CompilerOptions) => string; }
getScriptFileNames: () => rootFileNames,
>getScriptFileNames : () => string[]
>getScriptFileNames : () => string[], Symbol(getScriptFileNames, Decl(APISample_watcher.ts, 23, 50))
>() => rootFileNames : () => string[]
>rootFileNames : string[]
>rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(),
>getScriptVersion : (fileName: string) => string
>getScriptVersion : (fileName: string) => string, Symbol(getScriptVersion, Decl(APISample_watcher.ts, 24, 48))
>(fileName) => files[fileName] && files[fileName].version.toString() : (fileName: string) => string
>fileName : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
>files[fileName] && files[fileName].version.toString() : string
>files[fileName] : { version: number; }
>files : ts.Map<{ version: number; }>
>fileName : string
>files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
>files[fileName].version.toString() : string
>files[fileName].version.toString : (radix?: number) => string
>files[fileName].version : number
>files[fileName].version.toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
>files[fileName].version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
>files[fileName] : { version: number; }
>files : ts.Map<{ version: number; }>
>fileName : string
>version : number
>toString : (radix?: number) => string
>files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
>version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
>toString : (radix?: number) => string, Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
getScriptSnapshot: (fileName) => {
>getScriptSnapshot : (fileName: string) => ts.IScriptSnapshot
>getScriptSnapshot : (fileName: string) => ts.IScriptSnapshot, Symbol(getScriptSnapshot, Decl(APISample_watcher.ts, 25, 94))
>(fileName) => { if (!fs.existsSync(fileName)) { return undefined; } return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString()); } : (fileName: string) => ts.IScriptSnapshot
>fileName : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
if (!fs.existsSync(fileName)) {
>!fs.existsSync(fileName) : boolean
>fs.existsSync(fileName) : any
>fs.existsSync : any
>fs : any
>fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
>existsSync : any
>fileName : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
return undefined;
>undefined : undefined
>undefined : undefined, Symbol(undefined)
}
return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());
>ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString()) : ts.IScriptSnapshot
>ts.ScriptSnapshot.fromString : (text: string) => ts.IScriptSnapshot
>ts.ScriptSnapshot : typeof ts.ScriptSnapshot
>ts : typeof ts
>ScriptSnapshot : typeof ts.ScriptSnapshot
>fromString : (text: string) => ts.IScriptSnapshot
>ts.ScriptSnapshot.fromString : (text: string) => ts.IScriptSnapshot, Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1288, 27))
>ts.ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1287, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1287, 5))
>fromString : (text: string) => ts.IScriptSnapshot, Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1288, 27))
>fs.readFileSync(fileName).toString() : any
>fs.readFileSync(fileName).toString : any
>fs.readFileSync(fileName) : any
>fs.readFileSync : any
>fs : any
>fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
>readFileSync : any
>fileName : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
>toString : any
},
getCurrentDirectory: () => process.cwd(),
>getCurrentDirectory : () => any
>getCurrentDirectory : () => any, Symbol(getCurrentDirectory, Decl(APISample_watcher.ts, 32, 10))
>() => process.cwd() : () => any
>process.cwd() : any
>process.cwd : any
>process : any
>process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
>cwd : any
getCompilationSettings: () => options,
>getCompilationSettings : () => ts.CompilerOptions
>getCompilationSettings : () => ts.CompilerOptions, Symbol(getCompilationSettings, Decl(APISample_watcher.ts, 33, 49))
>() => options : () => ts.CompilerOptions
>options : ts.CompilerOptions
>options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 14, 39))
getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
>getDefaultLibFileName : (options: ts.CompilerOptions) => string
>getDefaultLibFileName : (options: ts.CompilerOptions) => string, Symbol(getDefaultLibFileName, Decl(APISample_watcher.ts, 34, 46))
>(options) => ts.getDefaultLibFilePath(options) : (options: ts.CompilerOptions) => string
>options : ts.CompilerOptions
>options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 35, 32))
>ts.getDefaultLibFilePath(options) : string
>ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string
>ts : typeof ts
>getDefaultLibFilePath : (options: ts.CompilerOptions) => string
>options : ts.CompilerOptions
>ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1737, 44))
>ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1737, 44))
>options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 35, 32))
};
// Create the language service files
const services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry())
>services : ts.LanguageService
>services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
>ts.createLanguageService(servicesHost, ts.createDocumentRegistry()) : ts.LanguageService
>ts.createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService
>ts : typeof ts
>createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService
>servicesHost : ts.LanguageServiceHost
>ts.createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService, Symbol(ts.createLanguageService, Decl(typescript.d.ts, 1735, 97))
>ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService, Symbol(ts.createLanguageService, Decl(typescript.d.ts, 1735, 97))
>servicesHost : ts.LanguageServiceHost, Symbol(servicesHost, Decl(APISample_watcher.ts, 23, 9))
>ts.createDocumentRegistry() : ts.DocumentRegistry
>ts.createDocumentRegistry : () => ts.DocumentRegistry
>ts : typeof ts
>createDocumentRegistry : () => ts.DocumentRegistry
>ts.createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1733, 193))
>ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1733, 193))
// Now let's watch the files
rootFileNames.forEach(fileName => {
>rootFileNames.forEach(fileName => { // First time around, emit all files emitFile(fileName); // Add a watch on the file to handle next change fs.watchFile(fileName, { persistent: true, interval: 250 }, (curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); }); }) : void
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
>rootFileNames : string[]
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
>rootFileNames.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>fileName => { // First time around, emit all files emitFile(fileName); // Add a watch on the file to handle next change fs.watchFile(fileName, { persistent: true, interval: 250 }, (curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); }); } : (fileName: string) => void
>fileName : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
// First time around, emit all files
emitFile(fileName);
>emitFile(fileName) : void
>emitFile : (fileName: string) => void
>fileName : string
>emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
// Add a watch on the file to handle next change
fs.watchFile(fileName,
>fs.watchFile(fileName, { persistent: true, interval: 250 }, (curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); }) : any
>fs.watchFile : any
>fs : any
>fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
>watchFile : any
>fileName : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
{ persistent: true, interval: 250 },
>{ persistent: true, interval: 250 } : { persistent: boolean; interval: number; }
>persistent : boolean
>interval : number
>persistent : boolean, Symbol(persistent, Decl(APISample_watcher.ts, 48, 13))
>true : boolean
>interval : number, Symbol(interval, Decl(APISample_watcher.ts, 48, 31))
>250 : number
(curr, prev) => {
>(curr, prev) => { // Check timestamp if (+curr.mtime <= +prev.mtime) { return; } // Update the version to signal a change in the file files[fileName].version++; // write the changes to disk emitFile(fileName); } : (curr: any, prev: any) => void
>curr : any
>prev : any
>curr : any, Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
>prev : any, Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
// Check timestamp
if (+curr.mtime <= +prev.mtime) {
>+curr.mtime <= +prev.mtime : boolean
>+curr.mtime : number
>curr.mtime : any
>curr : any
>curr : any, Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
>mtime : any
>+prev.mtime : number
>prev.mtime : any
>prev : any
>prev : any, Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
>mtime : any
return;
@ -206,175 +209,183 @@ function watch(rootFileNames: string[], options: ts.CompilerOptions) {
// Update the version to signal a change in the file
files[fileName].version++;
>files[fileName].version++ : number
>files[fileName].version : number
>files[fileName].version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
>files[fileName] : { version: number; }
>files : ts.Map<{ version: number; }>
>fileName : string
>version : number
>files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
>version : number, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
// write the changes to disk
emitFile(fileName);
>emitFile(fileName) : void
>emitFile : (fileName: string) => void
>fileName : string
>emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
});
});
function emitFile(fileName: string) {
>emitFile : (fileName: string) => void
>fileName : string
>emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
let output = services.getEmitOutput(fileName);
>output : ts.EmitOutput
>output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
>services.getEmitOutput(fileName) : ts.EmitOutput
>services.getEmitOutput : (fileName: string) => ts.EmitOutput
>services : ts.LanguageService
>getEmitOutput : (fileName: string) => ts.EmitOutput
>fileName : string
>services.getEmitOutput : (fileName: string) => ts.EmitOutput, Symbol(ts.LanguageService.getEmitOutput, Decl(typescript.d.ts, 1339, 132))
>services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
>getEmitOutput : (fileName: string) => ts.EmitOutput, Symbol(ts.LanguageService.getEmitOutput, Decl(typescript.d.ts, 1339, 132))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
if (!output.emitSkipped) {
>!output.emitSkipped : boolean
>output.emitSkipped : boolean
>output : ts.EmitOutput
>emitSkipped : boolean
>output.emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1542, 34))
>output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
>emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1542, 34))
console.log(`Emitting ${fileName}`);
>console.log(`Emitting ${fileName}`) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
>log : any
>fileName : string
>`Emitting ${fileName}` : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
}
else {
console.log(`Emitting ${fileName} failed`);
>console.log(`Emitting ${fileName} failed`) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
>log : any
>fileName : string
>`Emitting ${fileName} failed` : string
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
logErrors(fileName);
>logErrors(fileName) : void
>logErrors : (fileName: string) => void
>fileName : string
>logErrors : (fileName: string) => void, Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
}
output.outputFiles.forEach(o => {
>output.outputFiles.forEach(o => { fs.writeFileSync(o.name, o.text, "utf8"); }) : void
>output.outputFiles.forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void
>output.outputFiles : ts.OutputFile[]
>output : ts.EmitOutput
>outputFiles : ts.OutputFile[]
>forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void
>output.outputFiles.forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>output.outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1541, 26))
>output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
>outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1541, 26))
>forEach : (callbackfn: (value: ts.OutputFile, index: number, array: ts.OutputFile[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>o => { fs.writeFileSync(o.name, o.text, "utf8"); } : (o: ts.OutputFile) => void
>o : ts.OutputFile
>o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
fs.writeFileSync(o.name, o.text, "utf8");
>fs.writeFileSync(o.name, o.text, "utf8") : any
>fs.writeFileSync : any
>fs : any
>fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
>writeFileSync : any
>o.name : string
>o : ts.OutputFile
>name : string
>o.text : string
>o : ts.OutputFile
>text : string
>o.name : string, Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1550, 26))
>o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
>name : string, Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1550, 26))
>o.text : string, Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1552, 36))
>o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
>text : string, Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1552, 36))
>"utf8" : string
});
}
function logErrors(fileName: string) {
>logErrors : (fileName: string) => void
>fileName : string
>logErrors : (fileName: string) => void, Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
let allDiagnostics = services.getCompilerOptionsDiagnostics()
>allDiagnostics : ts.Diagnostic[]
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_watcher.ts, 80, 11))
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) .concat(services.getSemanticDiagnostics(fileName)) : ts.Diagnostic[]
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>services.getCompilerOptionsDiagnostics() .concat(services.getSyntacticDiagnostics(fileName)) : ts.Diagnostic[]
>services.getCompilerOptionsDiagnostics() .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>services.getCompilerOptionsDiagnostics() .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>services.getCompilerOptionsDiagnostics() : ts.Diagnostic[]
>services.getCompilerOptionsDiagnostics : () => ts.Diagnostic[]
>services : ts.LanguageService
>getCompilerOptionsDiagnostics : () => ts.Diagnostic[]
>services.getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1313, 63))
>services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
>getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1313, 63))
.concat(services.getSyntacticDiagnostics(fileName))
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>services.getSyntacticDiagnostics(fileName) : ts.Diagnostic[]
>services.getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[]
>services : ts.LanguageService
>getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[]
>fileName : string
>services.getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSyntacticDiagnostics, Decl(typescript.d.ts, 1311, 37))
>services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
>getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSyntacticDiagnostics, Decl(typescript.d.ts, 1311, 37))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
.concat(services.getSemanticDiagnostics(fileName));
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
>services.getSemanticDiagnostics(fileName) : ts.Diagnostic[]
>services.getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[]
>services : ts.LanguageService
>getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[]
>fileName : string
>services.getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSemanticDiagnostics, Decl(typescript.d.ts, 1312, 64))
>services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
>getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSemanticDiagnostics, Decl(typescript.d.ts, 1312, 64))
>fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
allDiagnostics.forEach(diagnostic => {
>allDiagnostics.forEach(diagnostic => { let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"); if (diagnostic.file) { let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); } else { console.log(` Error: ${message}`); } }) : void
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
>allDiagnostics : ts.Diagnostic[]
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void
>allDiagnostics.forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_watcher.ts, 80, 11))
>forEach : (callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => void, thisArg?: any) => void, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
>diagnostic => { let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"); if (diagnostic.file) { let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start); console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`); } else { console.log(` Error: ${message}`); } } : (diagnostic: ts.Diagnostic) => void
>diagnostic : ts.Diagnostic
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
>message : string
>message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
>ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n") : string
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
>ts : typeof ts
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
>diagnostic.messageText : string | ts.DiagnosticMessageChain
>diagnostic : ts.Diagnostic
>messageText : string | ts.DiagnosticMessageChain
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1200, 67))
>ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1200, 67))
>diagnostic.messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
>messageText : string | ts.DiagnosticMessageChain, Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
>"\n" : string
if (diagnostic.file) {
>diagnostic.file : ts.SourceFile
>diagnostic : ts.Diagnostic
>file : ts.SourceFile
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
>file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
>line : number
>character : number
>line : number, Symbol(line, Decl(APISample_watcher.ts, 87, 21))
>character : number, Symbol(character, Decl(APISample_watcher.ts, 87, 27))
>diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>diagnostic.file : ts.SourceFile
>diagnostic : ts.Diagnostic
>file : ts.SourceFile
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>diagnostic.start : number
>diagnostic : ts.Diagnostic
>start : number
>diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1263, 46))
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
>file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1263, 46))
>diagnostic.start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
>start : number, Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
>console.log(` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
>log : any
>diagnostic.file.fileName : string
>diagnostic.file : ts.SourceFile
>diagnostic : ts.Diagnostic
>file : ts.SourceFile
>fileName : string
>` Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}` : string
>diagnostic.file.fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
>diagnostic.file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>diagnostic : ts.Diagnostic, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
>file : ts.SourceFile, Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
>fileName : string, Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
>line + 1 : number
>line : number
>line : number, Symbol(line, Decl(APISample_watcher.ts, 87, 21))
>1 : number
>character + 1 : number
>character : number
>message : string
>character : number, Symbol(character, Decl(APISample_watcher.ts, 87, 27))
>1 : number
>message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
}
else {
console.log(` Error: ${message}`);
>console.log(` Error: ${message}`) : any
>console.log : any
>console : any
>console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
>log : any
>message : string
>` Error: ${message}` : string
>message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
}
});
}
@ -382,47 +393,51 @@ function watch(rootFileNames: string[], options: ts.CompilerOptions) {
// Initialize files constituting the program as all .ts files in the current directory
const currentDirectoryFiles = fs.readdirSync(process.cwd()).
>currentDirectoryFiles : any
>currentDirectoryFiles : any, Symbol(currentDirectoryFiles, Decl(APISample_watcher.ts, 98, 5))
>fs.readdirSync(process.cwd()). filter(fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts") : any
>fs.readdirSync(process.cwd()). filter : any
>fs.readdirSync(process.cwd()) : any
>fs.readdirSync : any
>fs : any
>fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
>readdirSync : any
>process.cwd() : any
>process.cwd : any
>process : any
>process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
>cwd : any
filter(fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts");
>filter : any
>fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts" : (fileName: any) => boolean
>fileName : any
>fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
>fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
>fileName.length >= 3 : boolean
>fileName.length : any
>fileName : any
>fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
>length : any
>3 : number
>fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
>fileName.substr(fileName.length - 3, 3) : any
>fileName.substr : any
>fileName : any
>fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
>substr : any
>fileName.length - 3 : number
>fileName.length : any
>fileName : any
>fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
>length : any
>3 : number
>3 : number
>".ts" : string
// Start the watcher
watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS });
>watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS }) : void
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void
>currentDirectoryFiles : any
>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void, Symbol(watch, Decl(APISample_watcher.ts, 12, 33))
>currentDirectoryFiles : any, Symbol(currentDirectoryFiles, Decl(APISample_watcher.ts, 98, 5))
>{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: ts.ModuleKind; }
>module : ts.ModuleKind
>ts.ModuleKind.CommonJS : ts.ModuleKind
>ts.ModuleKind : typeof ts.ModuleKind
>ts : typeof ts
>ModuleKind : typeof ts.ModuleKind
>CommonJS : ts.ModuleKind
>module : ts.ModuleKind, Symbol(module, Decl(APISample_watcher.ts, 102, 30))
>ts.ModuleKind.CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
>ts.ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
>ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
>ModuleKind : typeof ts.ModuleKind, Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
>CommonJS : ts.ModuleKind, Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))

32
tests/baselines/reference/AmbientModuleAndAmbientFunctionWithTheSameNameAndCommonRoot.types
View File

@ -1,33 +1,33 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
export var Origin: { x: number; y: number; }
>Origin : { x: number; y: number; }
>x : number
>y : number
>Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 1, 14))
>x : number, Symbol(x, Decl(module.d.ts, 1, 24))
>y : number, Symbol(y, Decl(module.d.ts, 1, 35))
}
=== tests/cases/conformance/internalModules/DeclarationMerging/function.d.ts ===
declare function Point(): { x: number; y: number; }
>Point : typeof Point
>x : number
>y : number
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
>x : number, Symbol(x, Decl(function.d.ts, 0, 27))
>y : number, Symbol(y, Decl(function.d.ts, 0, 38))
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var cl: { x: number; y: number; }
>cl : { x: number; y: number; }
>x : number
>y : number
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>x : number, Symbol(x, Decl(test.ts, 0, 9))
>y : number, Symbol(y, Decl(test.ts, 0, 20))
var cl = Point();
>cl : { x: number; y: number; }
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>Point() : { x: number; y: number; }
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
var cl = Point.Origin;
>cl : { x: number; y: number; }
>Point.Origin : { x: number; y: number; }
>Point : typeof Point
>Origin : { x: number; y: number; }
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>Point.Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
>Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))

50
tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types
View File

@ -1,59 +1,61 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
export module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
export var Origin: {
>Origin : { x: number; y: number; }
>Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 2, 18))
x: number;
>x : number
>x : number, Symbol(x, Decl(module.d.ts, 2, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(module.d.ts, 3, 22))
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/class.d.ts ===
declare module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
constructor(x: number, y: number);
>x : number
>y : number
>x : number, Symbol(x, Decl(class.d.ts, 2, 20))
>y : number, Symbol(y, Decl(class.d.ts, 2, 30))
x: number;
>x : number
>x : number, Symbol(x, Decl(class.d.ts, 2, 42))
y: number;
>y : number
>y : number, Symbol(y, Decl(class.d.ts, 3, 18))
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var p: { x: number; y: number; }
>p : { x: number; y: number; }
>x : number
>y : number
>p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>x : number, Symbol(x, Decl(test.ts, 0, 8))
>y : number, Symbol(y, Decl(test.ts, 0, 19))
var p = A.Point.Origin;
>p : { 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; }
>p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>A.Point.Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
>A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
>Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
>Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
var p = new A.Point(0, 0); // unexpected error here, bug 840000
>p : { x: number; y: number; }
>p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>new A.Point(0, 0) : A.Point
>A.Point : typeof A.Point
>A : typeof A
>Point : typeof A.Point
>A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(class.d.ts, 0, 0))
>Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(class.d.ts, 0, 18))
>0 : number
>0 : number

46
tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types
View File

@ -1,53 +1,55 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
export module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
export var Origin: {
>Origin : { x: number; y: number; }
>Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 2, 18))
x: number;
>x : number
>x : number, Symbol(x, Decl(module.d.ts, 2, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(module.d.ts, 3, 22))
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(classPoint.ts, 2, 20))
>y : number, Symbol(y, Decl(classPoint.ts, 2, 37))
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var p: { x: number; y: number; }
>p : { x: number; y: number; }
>x : number
>y : number
>p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>x : number, Symbol(x, Decl(test.ts, 0, 8))
>y : number, Symbol(y, Decl(test.ts, 0, 19))
var p = A.Point.Origin;
>p : { 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; }
>p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>A.Point.Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
>A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
>Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
>Origin : { x: number; y: number; }, Symbol(A.Point.Origin, Decl(module.d.ts, 2, 18))
var p = new A.Point(0, 0); // unexpected error here, bug 840000
>p : { x: number; y: number; }
>p : { x: number; y: number; }, Symbol(p, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>new A.Point(0, 0) : A.Point
>A.Point : typeof A.Point
>A : typeof A
>Point : typeof A.Point
>A.Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
>A : typeof A, Symbol(A, Decl(module.d.ts, 0, 0), Decl(classPoint.ts, 0, 0))
>Point : typeof A.Point, Symbol(A.Point, Decl(module.d.ts, 0, 18), Decl(classPoint.ts, 0, 10))
>0 : number
>0 : number

34
tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.types
View File

@ -1,37 +1,39 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
declare module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
export var Origin: { x: number; y: number; }
>Origin : { x: number; y: number; }
>x : number
>y : number
>Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.d.ts, 1, 14))
>x : number, Symbol(x, Decl(module.d.ts, 1, 24))
>y : number, Symbol(y, Decl(module.d.ts, 1, 35))
}
=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
function Point() {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
return { x: 0, y: 0 };
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(function.ts, 1, 12))
>0 : number
>y : number, Symbol(y, Decl(function.ts, 1, 18))
>0 : number
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var cl: { x: number; y: number; }
>cl : { x: number; y: number; }
>x : number
>y : number
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>x : number, Symbol(x, Decl(test.ts, 0, 9))
>y : number, Symbol(y, Decl(test.ts, 0, 20))
var cl = Point();
>cl : { x: number; y: number; }
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>Point() : { x: number; y: number; }
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
var cl = Point.Origin;
>cl : { x: number; y: number; }
>Point.Origin : { x: number; y: number; }
>Point : typeof Point
>Origin : { x: number; y: number; }
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
>Point.Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))
>Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.ts, 0, 0))
>Origin : { x: number; y: number; }, Symbol(Point.Origin, Decl(module.d.ts, 1, 14))

6
tests/baselines/reference/ArrowFunction4.types
View File

@ -1,8 +1,8 @@
=== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ArrowFunctions/ArrowFunction4.ts ===
var v = (a, b) => {
>v : (a: any, b: any) => void
>v : (a: any, b: any) => void, Symbol(v, Decl(ArrowFunction4.ts, 0, 3))
>(a, b) => { } : (a: any, b: any) => void
>a : any
>b : any
>a : any, Symbol(a, Decl(ArrowFunction4.ts, 0, 9))
>b : any, Symbol(b, Decl(ArrowFunction4.ts, 0, 11))
};

44
tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types
View File

@ -1,49 +1,55 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts ===
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 16))
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 33))
static Origin(): Point { return { x: 0, y: 0 }; }
>Origin : () => Point
>Point : Point
>Origin : () => Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 1, 55))
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 37))
>0 : number
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 3, 43))
>0 : number
}
module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 4, 1))
function Origin() { return ""; }// not an error, since not exported
>Origin : () => string
>Origin : () => string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 6, 14))
>"" : string
}
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 8, 1))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 20))
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 37))
static Origin(): Point { return { x: 0, y: 0 }; }
>Origin : () => Point
>Point : Point
>Origin : () => Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 13, 59))
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 41))
>0 : number
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 15, 47))
>0 : number
}
export module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 16, 5))
function Origin() { return ""; }// not an error since not exported
>Origin : () => string
>Origin : () => string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts, 18, 25))
>"" : string
}
}

44
tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types
View File

@ -1,49 +1,55 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts ===
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 16))
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 33))
static Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 1, 55))
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 28))
>0 : number
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 3, 34))
>0 : number
}
module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 0, 0), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 4, 1))
var Origin = ""; // not an error, since not exported
>Origin : string
>Origin : string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 7, 7))
>"" : string
}
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 8, 1))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 20))
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 37))
static Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Point.Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 13, 59))
>Point : Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 32))
>0 : number
>y : number, Symbol(y, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 15, 38))
>0 : number
}
export module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 11, 10), Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 16, 5))
var Origin = ""; // not an error since not exported
>Origin : string
>Origin : string, Symbol(Origin, Decl(ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts, 19, 11))
>"" : string
}
}

3
tests/baselines/reference/ES3For-ofTypeCheck2.types
View File

@ -1,5 +1,6 @@
=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck2.ts ===
for (var v of [true]) { }
>v : boolean
>v : boolean, Symbol(v, Decl(ES3For-ofTypeCheck2.ts, 0, 8))
>[true] : boolean[]
>true : boolean

6
tests/baselines/reference/ES3For-ofTypeCheck6.types
View File

@ -1,8 +1,8 @@
=== tests/cases/conformance/statements/for-ofStatements/ES3For-ofTypeCheck6.ts ===
var union: string[] | number[];
>union : string[] | number[]
>union : string[] | number[], Symbol(union, Decl(ES3For-ofTypeCheck6.ts, 0, 3))
for (var v of union) { }
>v : string | number
>union : string[] | number[]
>v : string | number, Symbol(v, Decl(ES3For-ofTypeCheck6.ts, 1, 8))
>union : string[] | number[], Symbol(union, Decl(ES3For-ofTypeCheck6.ts, 0, 3))

25
tests/baselines/reference/ES5For-of10.types
View File

@ -1,29 +1,30 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of10.ts ===
function foo() {
>foo : () => { x: number; }
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
return { x: 0 };
>{ x: 0 } : { x: number; }
>x : number
>x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
>0 : number
}
for (foo().x of []) {
>foo().x : number
>foo().x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
>foo() : { x: number; }
>foo : () => { x: number; }
>x : number
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
>x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
>[] : undefined[]
for (foo().x of [])
>foo().x : number
>foo().x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
>foo() : { x: number; }
>foo : () => { x: number; }
>x : number
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
>x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
>[] : undefined[]
var p = foo().x;
>p : number
>foo().x : number
>p : number, Symbol(p, Decl(ES5For-of10.ts, 5, 11))
>foo().x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
>foo() : { x: number; }
>foo : () => { x: number; }
>x : number
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of10.ts, 0, 0))
>x : number, Symbol(x, Decl(ES5For-of10.ts, 1, 12))
}

4
tests/baselines/reference/ES5For-of11.types
View File

@ -1,8 +1,8 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of11.ts ===
var v;
>v : any
>v : any, Symbol(v, Decl(ES5For-of11.ts, 0, 3))
for (v of []) { }
>v : any
>v : any, Symbol(v, Decl(ES5For-of11.ts, 0, 3))
>[] : undefined[]

9
tests/baselines/reference/ES5For-of13.types
View File

@ -1,9 +1,12 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of13.ts ===
for (let v of ['a', 'b', 'c']) {
>v : string
>v : string, Symbol(v, Decl(ES5For-of13.ts, 0, 8))
>['a', 'b', 'c'] : string[]
>'a' : string
>'b' : string
>'c' : string
var x = v;
>x : string
>v : string
>x : string, Symbol(x, Decl(ES5For-of13.ts, 1, 7))
>v : string, Symbol(v, Decl(ES5For-of13.ts, 0, 8))
}

6
tests/baselines/reference/ES5For-of14.types
View File

@ -1,9 +1,9 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of14.ts ===
for (const v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of14.ts, 0, 10))
>[] : undefined[]
var x = v;
>x : any
>v : any
>x : any, Symbol(x, Decl(ES5For-of14.ts, 1, 7))
>v : any, Symbol(v, Decl(ES5For-of14.ts, 0, 10))
}

10
tests/baselines/reference/ES5For-of15.types
View File

@ -1,17 +1,17 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of15.ts ===
for (let v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of15.ts, 0, 8))
>[] : undefined[]
v;
>v : any
>v : any, Symbol(v, Decl(ES5For-of15.ts, 0, 8))
for (const v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of15.ts, 2, 14))
>[] : undefined[]
var x = v;
>x : any
>v : any
>x : any, Symbol(x, Decl(ES5For-of15.ts, 3, 11))
>v : any, Symbol(v, Decl(ES5For-of15.ts, 2, 14))
}
}

12
tests/baselines/reference/ES5For-of16.types
View File

@ -1,21 +1,21 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of16.ts ===
for (let v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of16.ts, 0, 8))
>[] : undefined[]
v;
>v : any
>v : any, Symbol(v, Decl(ES5For-of16.ts, 0, 8))
for (let v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of16.ts, 2, 12))
>[] : undefined[]
var x = v;
>x : any
>v : any
>x : any, Symbol(x, Decl(ES5For-of16.ts, 3, 11))
>v : any, Symbol(v, Decl(ES5For-of16.ts, 2, 12))
v++;
>v++ : number
>v : any
>v : any, Symbol(v, Decl(ES5For-of16.ts, 2, 12))
}
}

8
tests/baselines/reference/ES5For-of18.types
View File

@ -1,16 +1,16 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of18.ts ===
for (let v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of18.ts, 0, 8))
>[] : undefined[]
v;
>v : any
>v : any, Symbol(v, Decl(ES5For-of18.ts, 0, 8))
}
for (let v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of18.ts, 3, 8))
>[] : undefined[]
v;
>v : any
>v : any, Symbol(v, Decl(ES5For-of18.ts, 3, 8))
}

10
tests/baselines/reference/ES5For-of19.types
View File

@ -1,20 +1,20 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of19.ts ===
for (let v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of19.ts, 0, 8))
>[] : undefined[]
v;
>v : any
>v : any, Symbol(v, Decl(ES5For-of19.ts, 0, 8))
function foo() {
>foo : () => void
>foo : () => void, Symbol(foo, Decl(ES5For-of19.ts, 1, 6))
for (const v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of19.ts, 3, 18))
>[] : undefined[]
v;
>v : any
>v : any, Symbol(v, Decl(ES5For-of19.ts, 3, 18))
}
}
}

6
tests/baselines/reference/ES5For-of2.types
View File

@ -1,9 +1,9 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of2.ts ===
for (var v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of2.ts, 0, 8))
>[] : undefined[]
var x = v;
>x : any
>v : any
>x : any, Symbol(x, Decl(ES5For-of2.ts, 1, 7))
>v : any, Symbol(v, Decl(ES5For-of2.ts, 0, 8))
}

4
tests/baselines/reference/ES5For-of21.types
View File

@ -1,9 +1,9 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of21.ts ===
for (let v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of21.ts, 0, 8))
>[] : undefined[]
for (let _i of []) { }
>_i : any
>_i : any, Symbol(_i, Decl(ES5For-of21.ts, 1, 12))
>[] : undefined[]
}

12
tests/baselines/reference/ES5For-of24.types
View File

@ -1,12 +1,16 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of24.ts ===
var a = [1, 2, 3];
>a : number[]
>a : number[], Symbol(a, Decl(ES5For-of24.ts, 0, 3))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
for (var v of a) {
>v : number
>a : number[]
>v : number, Symbol(v, Decl(ES5For-of24.ts, 1, 8))
>a : number[], Symbol(a, Decl(ES5For-of24.ts, 0, 3))
let a = 0;
>a : number
>a : number, Symbol(a, Decl(ES5For-of24.ts, 2, 7))
>0 : number
}

13
tests/baselines/reference/ES5For-of25.types
View File

@ -1,15 +1,18 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of25.ts ===
var a = [1, 2, 3];
>a : number[]
>a : number[], Symbol(a, Decl(ES5For-of25.ts, 0, 3))
>[1, 2, 3] : number[]
>1 : number
>2 : number
>3 : number
for (var v of a) {
>v : number
>a : number[]
>v : number, Symbol(v, Decl(ES5For-of25.ts, 1, 8))
>a : number[], Symbol(a, Decl(ES5For-of25.ts, 0, 3))
v;
>v : number
>v : number, Symbol(v, Decl(ES5For-of25.ts, 1, 8))
a;
>a : number[]
>a : number[], Symbol(a, Decl(ES5For-of25.ts, 0, 3))
}

9
tests/baselines/reference/ES5For-of3.types
View File

@ -1,9 +1,12 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of3.ts ===
for (var v of ['a', 'b', 'c'])
>v : string
>v : string, Symbol(v, Decl(ES5For-of3.ts, 0, 8))
>['a', 'b', 'c'] : string[]
>'a' : string
>'b' : string
>'c' : string
var x = v;
>x : string
>v : string
>x : string, Symbol(x, Decl(ES5For-of3.ts, 1, 7))
>v : string, Symbol(v, Decl(ES5For-of3.ts, 0, 8))

10
tests/baselines/reference/ES5For-of4.types
View File

@ -1,13 +1,13 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of4.ts ===
for (var v of [])
>v : any
>v : any, Symbol(v, Decl(ES5For-of4.ts, 0, 8))
>[] : undefined[]
var x = v;
>x : any
>v : any
>x : any, Symbol(x, Decl(ES5For-of4.ts, 1, 7))
>v : any, Symbol(v, Decl(ES5For-of4.ts, 0, 8))
var y = v;
>y : any
>v : any
>y : any, Symbol(y, Decl(ES5For-of4.ts, 2, 3))
>v : any, Symbol(v, Decl(ES5For-of4.ts, 0, 8))

6
tests/baselines/reference/ES5For-of5.types
View File

@ -1,9 +1,9 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of5.ts ===
for (var _a of []) {
>_a : any
>_a : any, Symbol(_a, Decl(ES5For-of5.ts, 0, 8))
>[] : undefined[]
var x = _a;
>x : any
>_a : any
>x : any, Symbol(x, Decl(ES5For-of5.ts, 1, 7))
>_a : any, Symbol(_a, Decl(ES5For-of5.ts, 0, 8))
}

10
tests/baselines/reference/ES5For-of6.types
View File

@ -1,16 +1,16 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of6.ts ===
for (var w of []) {
>w : any
>w : any, Symbol(w, Decl(ES5For-of6.ts, 0, 8))
>[] : undefined[]
for (var v of []) {
>v : any
>v : any, Symbol(v, Decl(ES5For-of6.ts, 1, 12))
>[] : undefined[]
var x = [w, v];
>x : any[]
>x : any[], Symbol(x, Decl(ES5For-of6.ts, 2, 11))
>[w, v] : any[]
>w : any
>v : any
>w : any, Symbol(w, Decl(ES5For-of6.ts, 0, 8))
>v : any, Symbol(v, Decl(ES5For-of6.ts, 1, 12))
}
}

25
tests/baselines/reference/ES5For-of9.types
View File

@ -1,30 +1,31 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-of9.ts ===
function foo() {
>foo : () => { x: number; }
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
return { x: 0 };
>{ x: 0 } : { x: number; }
>x : number
>x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
>0 : number
}
for (foo().x of []) {
>foo().x : number
>foo().x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
>foo() : { x: number; }
>foo : () => { x: number; }
>x : number
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
>x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
>[] : undefined[]
for (foo().x of []) {
>foo().x : number
>foo().x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
>foo() : { x: number; }
>foo : () => { x: number; }
>x : number
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
>x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
>[] : undefined[]
var p = foo().x;
>p : number
>foo().x : number
>p : number, Symbol(p, Decl(ES5For-of9.ts, 5, 11))
>foo().x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
>foo() : { x: number; }
>foo : () => { x: number; }
>x : number
>foo : () => { x: number; }, Symbol(foo, Decl(ES5For-of9.ts, 0, 0))
>x : number, Symbol(x, Decl(ES5For-of9.ts, 1, 12))
}
}

3
tests/baselines/reference/ES5For-ofTypeCheck1.types
View File

@ -1,4 +1,5 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck1.ts ===
for (var v of "") { }
>v : string
>v : string, Symbol(v, Decl(ES5For-ofTypeCheck1.ts, 0, 8))
>"" : string

3
tests/baselines/reference/ES5For-ofTypeCheck2.types
View File

@ -1,5 +1,6 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck2.ts ===
for (var v of [true]) { }
>v : boolean
>v : boolean, Symbol(v, Decl(ES5For-ofTypeCheck2.ts, 0, 8))
>[true] : boolean[]
>true : boolean

8
tests/baselines/reference/ES5For-ofTypeCheck3.types
View File

@ -1,9 +1,11 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck3.ts ===
var tuple: [string, number] = ["", 0];
>tuple : [string, number]
>tuple : [string, number], Symbol(tuple, Decl(ES5For-ofTypeCheck3.ts, 0, 3))
>["", 0] : [string, number]
>"" : string
>0 : number
for (var v of tuple) { }
>v : string | number
>tuple : [string, number]
>v : string | number, Symbol(v, Decl(ES5For-ofTypeCheck3.ts, 1, 8))
>tuple : [string, number], Symbol(tuple, Decl(ES5For-ofTypeCheck3.ts, 0, 3))

6
tests/baselines/reference/ES5For-ofTypeCheck4.types
View File

@ -1,8 +1,8 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck4.ts ===
var union: string | string[];
>union : string | string[]
>union : string | string[], Symbol(union, Decl(ES5For-ofTypeCheck4.ts, 0, 3))
for (const v of union) { }
>v : string
>union : string | string[]
>v : string, Symbol(v, Decl(ES5For-ofTypeCheck4.ts, 1, 10))
>union : string | string[], Symbol(union, Decl(ES5For-ofTypeCheck4.ts, 0, 3))

6
tests/baselines/reference/ES5For-ofTypeCheck5.types
View File

@ -1,8 +1,8 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck5.ts ===
var union: string | number[];
>union : string | number[]
>union : string | number[], Symbol(union, Decl(ES5For-ofTypeCheck5.ts, 0, 3))
for (var v of union) { }
>v : string | number
>union : string | number[]
>v : string | number, Symbol(v, Decl(ES5For-ofTypeCheck5.ts, 1, 8))
>union : string | number[], Symbol(union, Decl(ES5For-ofTypeCheck5.ts, 0, 3))

6
tests/baselines/reference/ES5For-ofTypeCheck6.types
View File

@ -1,8 +1,8 @@
=== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck6.ts ===
var union: string[] | number[];
>union : string[] | number[]
>union : string[] | number[], Symbol(union, Decl(ES5For-ofTypeCheck6.ts, 0, 3))
for (var v of union) { }
>v : string | number
>union : string[] | number[]
>v : string | number, Symbol(v, Decl(ES5For-ofTypeCheck6.ts, 1, 8))
>union : string[] | number[], Symbol(union, Decl(ES5For-ofTypeCheck6.ts, 0, 3))

8
tests/baselines/reference/ES5SymbolType1.types
View File

@ -1,10 +1,10 @@
=== tests/cases/conformance/Symbols/ES5SymbolType1.ts ===
var s: symbol;
>s : symbol
>s : symbol, Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
s.toString();
>s.toString() : string
>s.toString : () => string
>s : symbol
>toString : () => string
>s.toString : () => string, Symbol(Object.toString, Decl(lib.d.ts, 96, 26))
>s : symbol, Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
>toString : () => string, Symbol(Object.toString, Decl(lib.d.ts, 96, 26))

42
tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types
View File

@ -1,43 +1,45 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/EnumAndModuleWithSameNameAndCommonRoot.ts ===
enum enumdule {
>enumdule : enumdule
>enumdule : enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
Red, Blue
>Red : enumdule
>Blue : enumdule
>Red : enumdule, Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
>Blue : enumdule, Symbol(enumdule.Blue, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 1, 8))
}
module enumdule {
>enumdule : typeof enumdule
>enumdule : typeof enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 20))
>y : number, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 7, 37))
}
}
var x: enumdule;
>x : enumdule
>enumdule : enumdule
>x : enumdule, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 11, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 12, 3))
>enumdule : enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
var x = enumdule.Red;
>x : enumdule
>enumdule.Red : enumdule
>enumdule : typeof enumdule
>Red : enumdule
>x : enumdule, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 11, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 12, 3))
>enumdule.Red : enumdule, Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
>enumdule : typeof enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
>Red : enumdule, Symbol(enumdule.Red, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 15))
var y: { x: number; y: number };
>y : { x: number; y: number; }
>x : number
>y : number
>y : { x: number; y: number; }, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 15, 3))
>x : number, Symbol(x, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 8))
>y : number, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 19))
var y = new enumdule.Point(0, 0);
>y : { x: number; y: number; }
>y : { x: number; y: number; }, Symbol(y, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 14, 3), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 15, 3))
>new enumdule.Point(0, 0) : enumdule.Point
>enumdule.Point : typeof enumdule.Point
>enumdule : typeof enumdule
>Point : typeof enumdule.Point
>enumdule.Point : typeof enumdule.Point, Symbol(enumdule.Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
>enumdule : typeof enumdule, Symbol(enumdule, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 0, 0), Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 2, 1))
>Point : typeof enumdule.Point, Symbol(enumdule.Point, Decl(EnumAndModuleWithSameNameAndCommonRoot.ts, 4, 17))
>0 : number
>0 : number

29
tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types
View File

@ -1,36 +1,37 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWhichExtendsInterfaceWithInaccessibleType.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 0))
interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 2, 21))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 3, 18))
fromOrigin(p: Point): number;
>fromOrigin : (p: Point) => number
>p : Point
>Point : Point
>fromOrigin : (p: Point) => number, Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 4, 18))
>p : Point, Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 6, 19))
>Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
}
export class Point2d implements Point {
>Point2d : Point2d
>Point : Point
>Point2d : Point2d, Symbol(Point2d, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 7, 5))
>Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 20))
>y : number, Symbol(y, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 37))
fromOrigin(p: Point) {
>fromOrigin : (p: Point) => number
>p : Point
>Point : Point
>fromOrigin : (p: Point) => number, Symbol(fromOrigin, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 10, 59))
>p : Point, Symbol(p, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 12, 19))
>Point : Point, Symbol(Point, Decl(ExportClassWhichExtendsInterfaceWithInaccessibleType.ts, 0, 10))
return 1;
>1 : number
}
}
}

51
tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types
View File

@ -1,50 +1,55 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 0))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 24))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
>Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
>0 : number
>y : number, Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
>0 : number
export class Point3d extends Point {
>Point3d : Point3d
>Point : Point
>Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
>Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
z: number;
>z : number
>z : number, Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 40))
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>Origin3d : Point3d, Symbol(Origin3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
>Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
>x : number, Symbol(x, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
>0 : number
>y : number, Symbol(y, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
>0 : number
>z : number, Symbol(z, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
>0 : number
export class Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
>Line : Line<TPoint>, Symbol(Line, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 56))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
>Point : Point, Symbol(Point, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
constructor(public start: TPoint, public end: TPoint) { }
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
>start : TPoint, Symbol(start, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 20))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
>end : TPoint, Symbol(end, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 22))
}
}

18
tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.types
View File

@ -1,27 +1,27 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 0))
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 17))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
}
export class points {
>points : points
>points : points, Symbol(points, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 5, 5))
[idx: number]: Point;
>idx : number
>Point : Point
>idx : number, Symbol(idx, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 9, 9))
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
[idx: string]: Point;
>idx : string
>Point : Point
>idx : string, Symbol(idx, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 10, 9))
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
}
}

62
tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types
View File

@ -1,59 +1,65 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 0))
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 17))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
>0 : number
>y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
>0 : number
export class Point3d extends Point {
>Point3d : Point3d
>Point : Point
>Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
z: number;
>z : number
>z : number, Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 40))
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>Origin3d : Point3d, Symbol(Origin3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
>Point3d : Point3d, Symbol(Point3d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
>x : number, Symbol(x, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
>0 : number
>y : number, Symbol(y, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
>0 : number
>z : number, Symbol(z, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
>0 : number
export class Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
>Line : Line<TPoint>, Symbol(Line, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 56))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
constructor(public start: TPoint, public end: TPoint) { }
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
>start : TPoint, Symbol(start, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 20))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
>end : TPoint, Symbol(end, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 22))
static fromorigin2d(p: Point): Line<Point>{
>fromorigin2d : (p: Point) => Line<Point>
>p : Point
>Point : Point
>Line : Line<TPoint>
>Point : Point
>fromorigin2d : (p: Point) => Line<Point>, Symbol(Line.fromorigin2d, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 65))
>p : Point, Symbol(p, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 18, 28))
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
>Line : Line<TPoint>, Symbol(Line, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 56))
>Point : Point, Symbol(Point, Decl(ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
return null;
>null : null
}
}
}

36
tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types
View File

@ -1,39 +1,41 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 0))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 2, 24))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 3, 18))
}
export class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
constructor(public start: Point, public end: Point) { }
>start : Point
>Point : Point
>end : Point
>Point : Point
>start : Point, Symbol(start, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 20))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
>end : Point, Symbol(end, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 8, 40))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
}
export function fromOrigin(p: Point): Line {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
>Line : Line
>fromOrigin : (p: Point) => Line, Symbol(fromOrigin, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 9, 5))
>p : Point, Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 0, 10))
>Line : Line, Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>Line : typeof Line, Symbol(Line, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 5, 5))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
>x : number, Symbol(x, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 25))
>0 : number
>y : number, Symbol(y, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 12, 31))
>0 : number
>p : Point, Symbol(p, Decl(ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts, 11, 31))
}
}

36
tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types
View File

@ -1,39 +1,41 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 0))
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 2, 17))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 3, 18))
}
export class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
constructor(public start: Point, public end: Point) { }
>start : Point
>Point : Point
>end : Point
>Point : Point
>start : Point, Symbol(start, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 20))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
>end : Point, Symbol(end, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 8, 40))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
}
export function fromOrigin(p: Point): Line {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
>Line : Line
>fromOrigin : (p: Point) => Line, Symbol(fromOrigin, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 9, 5))
>p : Point, Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 11, 31))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 0, 10))
>Line : Line, Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>Line : typeof Line, Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 5, 5))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
>x : number, Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 25))
>0 : number
>y : number, Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 12, 31))
>0 : number
>p : Point, Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts, 11, 31))
}
}

36
tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types
View File

@ -1,39 +1,41 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 0))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 2, 24))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 3, 18))
}
class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 5, 5))
constructor(public start: Point, public end: Point) { }
>start : Point
>Point : Point
>end : Point
>Point : Point
>start : Point, Symbol(start, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 8, 20))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 10))
>end : Point, Symbol(end, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 8, 40))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 10))
}
export function fromOrigin(p: Point): Line {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
>Line : Line
>fromOrigin : (p: Point) => Line, Symbol(fromOrigin, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 9, 5))
>p : Point, Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 11, 31))
>Point : Point, Symbol(Point, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 0, 10))
>Line : Line, Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 5, 5))
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>Line : typeof Line, Symbol(Line, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 5, 5))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
>x : number, Symbol(x, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 25))
>0 : number
>y : number, Symbol(y, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 12, 31))
>0 : number
>p : Point, Symbol(p, Decl(ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts, 11, 31))
}
}

59
tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types
View File

@ -1,58 +1,63 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 0))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 2, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 3, 18))
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 14))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 32))
>0 : number
>y : number, Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 38))
>0 : number
export interface Point3d extends Point {
>Point3d : Point3d
>Point : Point
>Point3d : Point3d, Symbol(Point3d, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
z: number;
>z : number
>z : number, Symbol(z, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 9, 44))
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>Origin3d : Point3d, Symbol(Origin3d, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 14))
>Point3d : Point3d, Symbol(Point3d, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 7, 46))
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
>x : number, Symbol(x, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 36))
>0 : number
>y : number, Symbol(y, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 42))
>0 : number
>z : number, Symbol(z, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 48))
>0 : number
export interface Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
>Line : Line<TPoint>, Symbol(Line, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 13, 56))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 0, 10))
new (start: TPoint, end: TPoint);
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
>start : TPoint, Symbol(start, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 13))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))
>end : TPoint, Symbol(end, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 27))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))
start: TPoint;
>start : TPoint
>TPoint : TPoint
>start : TPoint, Symbol(start, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 16, 41))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))
end: TPoint;
>end : TPoint
>TPoint : TPoint
>end : TPoint, Symbol(end, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 17, 22))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts, 15, 26))
}
}

18
tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.types
View File

@ -1,27 +1,27 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
module A {
>A : unknown
>A : any, Symbol(A, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 0))
interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 2, 21))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 3, 18))
}
export interface points {
>points : points
>points : points, Symbol(points, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 5, 5))
[idx: number]: Point;
>idx : number
>Point : Point
>idx : number, Symbol(idx, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 9, 9))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
[idx: string]: Point;
>idx : string
>Point : Point
>idx : string, Symbol(idx, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 10, 9))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts, 0, 10))
}
}

59
tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.types
View File

@ -1,58 +1,63 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 0))
interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 2, 21))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 3, 18))
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 14))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 32))
>0 : number
>y : number, Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 38))
>0 : number
export interface Point3d extends Point {
>Point3d : Point3d
>Point : Point
>Point3d : Point3d, Symbol(Point3d, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
z: number;
>z : number
>z : number, Symbol(z, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 9, 44))
}
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>Origin3d : Point3d, Symbol(Origin3d, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 14))
>Point3d : Point3d, Symbol(Point3d, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 7, 46))
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
>x : number, Symbol(x, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 36))
>0 : number
>y : number, Symbol(y, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 42))
>0 : number
>z : number, Symbol(z, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 48))
>0 : number
export interface Line<TPoint extends Point>{
>Line : Line<TPoint>
>TPoint : TPoint
>Point : Point
>Line : Line<TPoint>, Symbol(Line, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 13, 56))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))
>Point : Point, Symbol(Point, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 0, 10))
new (start: TPoint, end: TPoint);
>start : TPoint
>TPoint : TPoint
>end : TPoint
>TPoint : TPoint
>start : TPoint, Symbol(start, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 13))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))
>end : TPoint, Symbol(end, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 27))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))
start: TPoint;
>start : TPoint
>TPoint : TPoint
>start : TPoint, Symbol(start, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 16, 41))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))
end: TPoint;
>end : TPoint
>TPoint : TPoint
>end : TPoint, Symbol(end, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 18, 22))
>TPoint : TPoint, Symbol(TPoint, Decl(ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts, 15, 26))
}
}

44
tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.types
View File

@ -1,47 +1,51 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportModuleWithAccessibleTypesOnItsExportedMembers.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 0))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 10))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 3, 20))
>y : number, Symbol(y, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 3, 37))
}
export module B {
>B : typeof B
>B : typeof B, Symbol(B, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 4, 5))
export var Origin: Point = new Point(0, 0);
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 7, 18))
>Point : Point, Symbol(Point, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 10))
>new Point(0, 0) : Point
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 10))
>0 : number
>0 : number
export class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 7, 51))
constructor(start: Point, end: Point) {
>start : Point
>Point : Point
>end : Point
>Point : Point
>start : Point, Symbol(start, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 10, 24))
>Point : Point, Symbol(Point, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 10))
>end : Point, Symbol(end, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 10, 37))
>Point : Point, Symbol(Point, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 10))
}
static fromOrigin(p: Point) {
>fromOrigin : (p: Point) => Line
>p : Point
>Point : Point
>fromOrigin : (p: Point) => Line, Symbol(Line.fromOrigin, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 12, 13))
>p : Point, Symbol(p, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 14, 30))
>Point : Point, Symbol(Point, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 0, 10))
return new Line({ x: 0, y: 0 }, p);
>new Line({ x: 0, y: 0 }, p) : Line
>Line : typeof Line
>Line : typeof Line, Symbol(Line, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 7, 51))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>p : Point
>x : number, Symbol(x, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 33))
>0 : number
>y : number, Symbol(y, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 15, 39))
>0 : number
>p : Point, Symbol(p, Decl(ExportModuleWithAccessibleTypesOnItsExportedMembers.ts, 14, 30))
}
}
}

32
tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.types
View File

@ -1,30 +1,36 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 0))
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 3, 20))
>y : number, Symbol(y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 3, 37))
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 14))
>Point : Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 32))
>0 : number
>y : number, Symbol(y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 6, 38))
>0 : number
export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
>Unity : { start: Point; end: Point; }
>Unity : { start: Point; end: Point; }, Symbol(Unity, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 14))
>{ start: new Point(0, 0), end: new Point(1, 0) } : { start: Point; end: Point; }
>start : Point
>start : Point, Symbol(start, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 24))
>new Point(0, 0) : Point
>Point : typeof Point
>end : Point
>Point : typeof Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
>0 : number
>0 : number
>end : Point, Symbol(end, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 8, 48))
>new Point(1, 0) : Point
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts, 0, 10))
>1 : number
>0 : number
}

31
tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.types
View File

@ -1,31 +1,32 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 0, 0))
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 0, 10))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 3, 20))
>y : number, Symbol(y, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 3, 37))
}
export var UnitSquare : {
>UnitSquare : { top: { left: Point; right: Point; }; bottom: { left: Point; right: Point; }; }
>UnitSquare : { top: { left: Point; right: Point; }; bottom: { left: Point; right: Point; }; }, Symbol(UnitSquare, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 6, 14))
top: { left: Point, right: Point },
>top : { left: Point; right: Point; }
>left : Point
>Point : Point
>right : Point
>Point : Point
>top : { left: Point; right: Point; }, Symbol(top, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 6, 29))
>left : Point, Symbol(left, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 7, 14))
>Point : Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 0, 10))
>right : Point, Symbol(right, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 7, 27))
>Point : Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 0, 10))
bottom: { left: Point, right: Point }
>bottom : { left: Point; right: Point; }
>left : Point
>Point : Point
>right : Point
>Point : Point
>bottom : { left: Point; right: Point; }, Symbol(bottom, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 7, 43))
>left : Point, Symbol(left, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 8, 17))
>Point : Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 0, 10))
>right : Point, Symbol(right, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 8, 30))
>Point : Point, Symbol(Point, Decl(ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.ts, 0, 10))
} = null;
>null : null
}

18
tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.types
View File

@ -1,22 +1,22 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 0))
class B {
>B : B
>B : B, Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))
id: number;
>id : number
>id : number, Symbol(id, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 1, 13))
}
export var beez: Array<B>;
>beez : B[]
>Array : T[]
>B : B
>beez : B[], Symbol(beez, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 5, 14))
>Array : T[], Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
>B : B, Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))
export var beez2 = new Array<B>();
>beez2 : B[]
>beez2 : B[], Symbol(beez2, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 6, 14))
>new Array<B>() : B[]
>Array : ArrayConstructor
>B : B
>Array : ArrayConstructor, Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
>B : B, Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10))
}

18
tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.types
View File

@ -1,23 +1,25 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithAccessibleTypeInTypeAnnotation.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 0, 0))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 2, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 3, 18))
}
// valid since Point is exported
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 14))
>Point : Point, Symbol(Point, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 32))
>0 : number
>y : number, Symbol(y, Decl(ExportVariableWithAccessibleTypeInTypeAnnotation.ts, 8, 38))
>0 : number
}

37
tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.types
View File

@ -1,40 +1,45 @@
=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithInaccessibleTypeInTypeAnnotation.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 0))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 2, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 3, 18))
}
// valid since Point is exported
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 14))
>Point : Point, Symbol(Point, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 32))
>0 : number
>y : number, Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 38))
>0 : number
interface Point3d extends Point {
>Point3d : Point3d
>Point : Point
>Point3d : Point3d, Symbol(Point3d, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 46))
>Point : Point, Symbol(Point, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 0, 10))
z: number;
>z : number
>z : number, Symbol(z, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 10, 37))
}
// invalid Point3d is not exported
export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
>Origin3d : Point3d
>Point3d : Point3d
>Origin3d : Point3d, Symbol(Origin3d, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 14))
>Point3d : Point3d, Symbol(Point3d, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 8, 46))
>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
>x : number
>y : number
>z : number
>x : number, Symbol(x, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 36))
>0 : number
>y : number, Symbol(y, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 42))
>0 : number
>z : number, Symbol(z, Decl(ExportVariableWithInaccessibleTypeInTypeAnnotation.ts, 15, 48))
>0 : number
}

54
tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types
View File

@ -1,54 +1,58 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(function.ts, 0, 0))
export function Point() {
>Point : () => { x: number; y: number; }
>Point : () => { x: number; y: number; }, Symbol(Point, Decl(function.ts, 0, 10))
return { x: 0, y: 0 };
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(function.ts, 2, 16))
>0 : number
>y : number, Symbol(y, Decl(function.ts, 2, 22))
>0 : number
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts ===
module B {
>B : typeof B
>B : typeof B, Symbol(B, Decl(module.ts, 0, 0))
export module Point {
>Point : typeof Point
>Point : typeof Point, Symbol(Point, Decl(module.ts, 0, 10))
export var Origin = { x: 0, y: 0 };
>Origin : { x: number; y: number; }
>Origin : { x: number; y: number; }, Symbol(Origin, Decl(module.ts, 2, 18))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(module.ts, 2, 29))
>0 : number
>y : number, Symbol(y, Decl(module.ts, 2, 35))
>0 : number
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
var fn: () => { x: number; y: number };
>fn : () => { x: number; y: number; }
>x : number
>y : number
>fn : () => { x: number; y: number; }, Symbol(fn, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3))
>x : number, Symbol(x, Decl(test.ts, 0, 15))
>y : number, Symbol(y, Decl(test.ts, 0, 26))
var fn = A.Point;
>fn : () => { x: number; y: number; }
>A.Point : () => { x: number; y: number; }
>A : typeof A
>Point : () => { x: number; y: number; }
>fn : () => { x: number; y: number; }, Symbol(fn, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3))
>A.Point : () => { x: number; y: number; }, Symbol(A.Point, Decl(function.ts, 0, 10))
>A : typeof A, Symbol(A, Decl(function.ts, 0, 0))
>Point : () => { x: number; y: number; }, Symbol(A.Point, Decl(function.ts, 0, 10))
var cl: { x: number; y: number; }
>cl : { x: number; y: number; }
>x : number
>y : number
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3))
>x : number, Symbol(x, Decl(test.ts, 3, 9))
>y : number, Symbol(y, Decl(test.ts, 3, 20))
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; }
>cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 3, 3), Decl(test.ts, 4, 3))
>B.Point.Origin : { x: number; y: number; }, Symbol(B.Point.Origin, Decl(module.ts, 2, 18))
>B.Point : typeof B.Point, Symbol(B.Point, Decl(module.ts, 0, 10))
>B : typeof B, Symbol(B, Decl(module.ts, 0, 0))
>Point : typeof B.Point, Symbol(B.Point, Decl(module.ts, 0, 10))
>Origin : { x: number; y: number; }, Symbol(B.Point.Origin, Decl(module.ts, 2, 18))

4
tests/baselines/reference/FunctionDeclaration2_es6.types
View File

@ -1,5 +1,5 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration2_es6.ts ===
function f(yield) {
>f : (yield: any) => void
>yield : any
>f : (yield: any) => void, Symbol(f, Decl(FunctionDeclaration2_es6.ts, 0, 0))
>yield : any, Symbol(yield, Decl(FunctionDeclaration2_es6.ts, 0, 11))
}

2
tests/baselines/reference/FunctionDeclaration4_es6.types
View File

@ -1,4 +1,4 @@
=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration4_es6.ts ===
function yield() {
>yield : () => void
>yield : () => void, Symbol(yield, Decl(FunctionDeclaration4_es6.ts, 0, 0))
}

42
tests/baselines/reference/ModuleAndEnumWithSameNameAndCommonRoot.types
View File

@ -1,43 +1,45 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/ModuleAndEnumWithSameNameAndCommonRoot.ts ===
module enumdule {
>enumdule : typeof enumdule
>enumdule : typeof enumdule, Symbol(enumdule, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 0), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 5, 1))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 17))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 3, 20))
>y : number, Symbol(y, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 3, 37))
}
}
enum enumdule {
>enumdule : enumdule
>enumdule : enumdule, Symbol(enumdule, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 0), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 5, 1))
Red, Blue
>Red : enumdule
>Blue : enumdule
>Red : enumdule, Symbol(enumdule.Red, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 7, 15))
>Blue : enumdule, Symbol(enumdule.Blue, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 8, 8))
}
var x: enumdule;
>x : enumdule
>enumdule : enumdule
>x : enumdule, Symbol(x, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 11, 3), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 12, 3))
>enumdule : enumdule, Symbol(enumdule, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 0), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 5, 1))
var x = enumdule.Red;
>x : enumdule
>enumdule.Red : enumdule
>enumdule : typeof enumdule
>Red : enumdule
>x : enumdule, Symbol(x, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 11, 3), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 12, 3))
>enumdule.Red : enumdule, Symbol(enumdule.Red, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 7, 15))
>enumdule : typeof enumdule, Symbol(enumdule, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 0), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 5, 1))
>Red : enumdule, Symbol(enumdule.Red, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 7, 15))
var y: { x: number; y: number };
>y : { x: number; y: number; }
>x : number
>y : number
>y : { x: number; y: number; }, Symbol(y, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 14, 3), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 15, 3))
>x : number, Symbol(x, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 14, 8))
>y : number, Symbol(y, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 14, 19))
var y = new enumdule.Point(0, 0);
>y : { x: number; y: number; }
>y : { x: number; y: number; }, Symbol(y, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 14, 3), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 15, 3))
>new enumdule.Point(0, 0) : enumdule.Point
>enumdule.Point : typeof enumdule.Point
>enumdule : typeof enumdule
>Point : typeof enumdule.Point
>enumdule.Point : typeof enumdule.Point, Symbol(enumdule.Point, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 17))
>enumdule : typeof enumdule, Symbol(enumdule, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 0), Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 5, 1))
>Point : typeof enumdule.Point, Symbol(enumdule.Point, Decl(ModuleAndEnumWithSameNameAndCommonRoot.ts, 0, 17))
>0 : number
>0 : number

4
tests/baselines/reference/Protected5.types
View File

@ -1,7 +1,7 @@
=== tests/cases/conformance/parser/ecmascript5/Protected/Protected5.ts ===
class C {
>C : C
>C : C, Symbol(C, Decl(Protected5.ts, 0, 0))
protected static m() { }
>m : () => void
>m : () => void, Symbol(C.m, Decl(Protected5.ts, 0, 9))
}

6
tests/baselines/reference/Protected8.types
View File

@ -1,10 +1,10 @@
=== tests/cases/conformance/parser/ecmascript5/Protected/Protected8.ts ===
interface I {
>I : I
>I : I, Symbol(I, Decl(Protected8.ts, 0, 0))
protected
>protected : any
>protected : any, Symbol(protected, Decl(Protected8.ts, 0, 13))
p
>p : any
>p : any, Symbol(p, Decl(Protected8.ts, 1, 12))
}

4
tests/baselines/reference/Protected9.types
View File

@ -1,7 +1,7 @@
=== tests/cases/conformance/parser/ecmascript5/Protected/Protected9.ts ===
class C {
>C : C
>C : C, Symbol(C, Decl(Protected9.ts, 0, 0))
constructor(protected p) { }
>p : any
>p : any, Symbol(p, Decl(Protected9.ts, 1, 15))
}

2
tests/baselines/reference/TupleType1.types
View File

@ -1,4 +1,4 @@
=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType1.ts ===
var v: [number]
>v : [number]
>v : [number], Symbol(v, Decl(TupleType1.ts, 0, 3))

2
tests/baselines/reference/TupleType2.types
View File

@ -1,4 +1,4 @@
=== tests/cases/conformance/parser/ecmascript5/TupleTypes/TupleType2.ts ===
var v: [number, string]
>v : [number, string]
>v : [number, string], Symbol(v, Decl(TupleType2.ts, 0, 3))

82
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.types
View File

@ -1,82 +1,82 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 5, 1))
export class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 1, 24))
y: number;
>y : number
>y : number, Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 2, 18))
}
}
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 5, 1))
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 7, 10))
fromCarthesian(p: A.Point) {
>fromCarthesian : (p: A.Point) => { x: number; y: number; }
>p : A.Point
>A : unknown
>Point : A.Point
>fromCarthesian : (p: A.Point) => { x: number; y: number; }, Symbol(fromCarthesian, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 8, 17))
>p : A.Point, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 9, 23))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 5, 1))
>Point : A.Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 10))
return { x: p.x, y: p.y };
>{ x: p.x, y: p.y } : { x: number; y: number; }
>x : number
>p.x : number
>p : A.Point
>x : number
>y : number
>p.y : number
>p : A.Point
>y : number
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 10, 20))
>p.x : number, Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 1, 24))
>p : A.Point, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 9, 23))
>x : number, Symbol(Point.x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 1, 24))
>y : number, Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 10, 28))
>p.y : number, Symbol(Point.y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 2, 18))
>p : A.Point, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 9, 23))
>y : number, Symbol(Point.y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 2, 18))
}
}
}
// ensure merges as expected
var p: { x: number; y: number; };
>p : { x: number; y: number; }
>x : number
>y : number
>p : { x: number; y: number; }, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 16, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 17, 3))
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 16, 8))
>y : number, Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 16, 19))
var p: A.Point;
>p : { x: number; y: number; }
>A : unknown
>Point : A.Point
>p : { x: number; y: number; }, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 16, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 17, 3))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 5, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 0, 10))
module X.Y.Z {
>X : typeof X
>Y : typeof Y
>Z : typeof Z
>X : typeof X, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 17, 15), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 23, 1))
>Y : typeof Y, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 9), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 25, 10))
>Z : typeof Z, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 11), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 26, 21))
export class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 14))
length: number;
>length : number
>length : number, Symbol(length, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 20, 23))
}
}
module X {
>X : typeof X
>X : typeof X, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 17, 15), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 23, 1))
export module Y {
>Y : typeof Y
>Y : typeof Y, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 9), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 25, 10))
export module Z {
>Z : typeof Z
>Z : typeof Z, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 11), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 26, 21))
class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 27, 25))
name: string;
>name : string
>name : string, Symbol(name, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 28, 24))
}
}
}
@ -84,14 +84,14 @@ module X {
// ensure merges as expected
var l: { length: number; }
>l : { length: number; }
>length : number
>l : { length: number; }, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 36, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 37, 3))
>length : number, Symbol(length, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 36, 8))
var l: X.Y.Z.Line;
>l : { length: number; }
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line
>l : { length: number; }, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 36, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 37, 3))
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 17, 15), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 23, 1))
>Y : any, Symbol(X.Y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 9), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 25, 10))
>Z : any, Symbol(X.Y.Z, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 11), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 26, 21))
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts, 19, 14))

102
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.types
View File

@ -1,103 +1,103 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts ===
module A {
>A : unknown
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 1, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 2, 18))
toCarth(): Point;
>toCarth : () => Point
>Point : Point
>toCarth : () => Point, Symbol(toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 3, 18))
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
}
}
module A {
>A : unknown
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 8, 10))
fromCarth(): Point;
>fromCarth : () => Point
>Point : Point
>fromCarth : () => Point, Symbol(fromCarth, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 9, 21))
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 8, 10))
}
}
// ensure merges as expected
var p: { x: number; y: number; toCarth(): A.Point; };
>p : { x: number; y: number; toCarth(): A.Point; }
>x : number
>y : number
>toCarth : () => A.Point
>A : unknown
>Point : A.Point
>p : { x: number; y: number; toCarth(): A.Point; }, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 15, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 16, 3))
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 15, 8))
>y : number, Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 15, 19))
>toCarth : () => A.Point, Symbol(toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 15, 30))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
var p: A.Point;
>p : { x: number; y: number; toCarth(): A.Point; }
>A : unknown
>Point : A.Point
>p : { x: number; y: number; toCarth(): A.Point; }, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 15, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 16, 3))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
module X.Y.Z {
>X : unknown
>Y : unknown
>Z : unknown
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 16, 15), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 22, 1))
>Y : any, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 9), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 24, 10))
>Z : any, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 11), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 25, 20))
export interface Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 14))
new (start: A.Point, end: A.Point);
>start : A.Point
>A : unknown
>Point : A.Point
>end : A.Point
>A : unknown
>Point : A.Point
>start : A.Point, Symbol(start, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 20, 13))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
>end : A.Point, Symbol(end, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 20, 28))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
}
}
module X {
>X : unknown
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 16, 15), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 22, 1))
export module Y.Z {
>Y : unknown
>Z : unknown
>Y : any, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 9), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 24, 10))
>Z : any, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 11), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 25, 20))
interface Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 25, 23))
start: A.Point;
>start : A.Point
>A : unknown
>Point : A.Point
>start : A.Point, Symbol(start, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 26, 24))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
end: A.Point;
>end : A.Point
>A : unknown
>Point : A.Point
>end : A.Point, Symbol(end, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 27, 27))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
}
}
}
// ensure merges as expected
var l: { new (s: A.Point, e: A.Point); }
>l : new (s: A.Point, e: A.Point) => any
>s : A.Point
>A : unknown
>Point : A.Point
>e : A.Point
>A : unknown
>Point : A.Point
>l : new (s: A.Point, e: A.Point) => any, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 34, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 35, 3))
>s : A.Point, Symbol(s, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 34, 14))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
>e : A.Point, Symbol(e, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 34, 25))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 0, 10))
var l: X.Y.Z.Line;
>l : new (s: A.Point, e: A.Point) => any
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line
>l : new (s: A.Point, e: A.Point) => any, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 34, 3), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 35, 3))
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 16, 15), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 22, 1))
>Y : any, Symbol(X.Y, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 9), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 24, 10))
>Z : any, Symbol(X.Y.Z, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 11), Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 25, 20))
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line, Decl(TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts, 18, 14))

139
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types
View File

@ -1,66 +1,69 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(part1.ts, 1, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(part1.ts, 2, 18))
}
export module Utils {
>Utils : typeof Utils
>Utils : typeof Utils, Symbol(Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
export function mirror<T extends Point>(p: T) {
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>T : T
>Point : Point
>p : T
>T : T
>mirror : <T extends Point>(p: T) => { x: number; y: number; }, Symbol(mirror, Decl(part1.ts, 6, 25))
>T : T, Symbol(T, Decl(part1.ts, 7, 31))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
>p : T, Symbol(p, Decl(part1.ts, 7, 48))
>T : T, Symbol(T, Decl(part1.ts, 7, 31))
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
>x : number, Symbol(x, Decl(part1.ts, 8, 20))
>p.y : number, Symbol(Point.y, Decl(part1.ts, 2, 18))
>p : T, Symbol(p, Decl(part1.ts, 7, 48))
>y : number, Symbol(Point.y, Decl(part1.ts, 2, 18))
>y : number, Symbol(y, Decl(part1.ts, 8, 28))
>p.x : number, Symbol(Point.x, Decl(part1.ts, 1, 28))
>p : T, Symbol(p, Decl(part1.ts, 7, 48))
>x : number, Symbol(Point.x, Decl(part1.ts, 1, 28))
}
}
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(part1.ts, 11, 14))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(part1.ts, 11, 32))
>0 : number
>y : number, Symbol(y, Decl(part1.ts, 11, 38))
>0 : number
}
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
// not a collision, since we don't export
var Origin: string = "0,0";
>Origin : string
>Origin : string, Symbol(Origin, Decl(part2.ts, 2, 7))
>"0,0" : string
export module Utils {
>Utils : typeof Utils
>Utils : typeof Utils, Symbol(Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
export class Plane {
>Plane : Plane
>Plane : Plane, Symbol(Plane, Decl(part2.ts, 4, 25))
constructor(public tl: Point, public br: Point) { }
>tl : Point
>Point : Point
>br : Point
>Point : Point
>tl : Point, Symbol(tl, Decl(part2.ts, 6, 24))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
>br : Point, Symbol(br, Decl(part2.ts, 6, 41))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
}
}
}
@ -69,57 +72,59 @@ module A {
// test the merging actually worked
var o: { x: number; y: number };
>o : { x: number; y: number; }
>x : number
>y : number
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>x : number, Symbol(x, Decl(part3.ts, 2, 8))
>y : number, Symbol(y, Decl(part3.ts, 2, 19))
var o: A.Point;
>o : { x: number; y: number; }
>A : unknown
>Point : A.Point
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Point : A.Point, Symbol(A.Point, Decl(part1.ts, 0, 10))
var o = A.Origin;
>o : { x: number; y: number; }
>A.Origin : A.Point
>A : typeof A
>Origin : A.Point
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>A.Origin : A.Point, Symbol(A.Origin, Decl(part1.ts, 11, 14))
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Origin : A.Point, Symbol(A.Origin, Decl(part1.ts, 11, 14))
var o = A.Utils.mirror(o);
>o : { x: number; y: number; }
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>A.Utils.mirror(o) : { x: number; y: number; }
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof A.Utils
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
>o : { x: number; y: number; }
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror, Decl(part1.ts, 6, 25))
>A.Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror, Decl(part1.ts, 6, 25))
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
var p: { tl: A.Point; br: A.Point };
>p : { tl: A.Point; br: A.Point; }
>tl : A.Point
>A : unknown
>Point : A.Point
>br : A.Point
>A : unknown
>Point : A.Point
>p : { tl: A.Point; br: A.Point; }, Symbol(p, Decl(part3.ts, 7, 3), Decl(part3.ts, 8, 3), Decl(part3.ts, 9, 3))
>tl : A.Point, Symbol(tl, Decl(part3.ts, 7, 8))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Point : A.Point, Symbol(A.Point, Decl(part1.ts, 0, 10))
>br : A.Point, Symbol(br, Decl(part3.ts, 7, 21))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Point : A.Point, Symbol(A.Point, Decl(part1.ts, 0, 10))
var p: A.Utils.Plane;
>p : { tl: A.Point; br: A.Point; }
>A : unknown
>Utils : unknown
>Plane : A.Utils.Plane
>p : { tl: A.Point; br: A.Point; }, Symbol(p, Decl(part3.ts, 7, 3), Decl(part3.ts, 8, 3), Decl(part3.ts, 9, 3))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Utils : any, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
>Plane : A.Utils.Plane, Symbol(A.Utils.Plane, Decl(part2.ts, 4, 25))
var p = new A.Utils.Plane(o, { x: 1, y: 1 });
>p : { tl: A.Point; br: A.Point; }
>p : { tl: A.Point; br: A.Point; }, Symbol(p, Decl(part3.ts, 7, 3), Decl(part3.ts, 8, 3), Decl(part3.ts, 9, 3))
>new A.Utils.Plane(o, { x: 1, y: 1 }) : A.Utils.Plane
>A.Utils.Plane : typeof A.Utils.Plane
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof A.Utils
>Plane : typeof A.Utils.Plane
>o : { x: number; y: number; }
>A.Utils.Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane, Decl(part2.ts, 4, 25))
>A.Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 2, 31))
>Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane, Decl(part2.ts, 4, 25))
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>{ x: 1, y: 1 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(part3.ts, 9, 30))
>1 : number
>y : number, Symbol(y, Decl(part3.ts, 9, 36))
>1 : number

120
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.types
View File

@ -1,112 +1,112 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts ===
module A {
>A : unknown
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 1, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 2, 18))
toCarth(): Point;
>toCarth : () => Point
>Point : Point
>toCarth : () => Point, Symbol(toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 3, 18))
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
}
}
module A {
>A : unknown
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
fromCarth(): Point;
>fromCarth : () => Point
>Point : Point
>fromCarth : () => Point, Symbol(fromCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 9, 28))
>Point : Point, Symbol(Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
}
}
// ensure merges as expected
var p: { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; };
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
>x : number
>y : number
>toCarth : () => A.Point
>A : unknown
>Point : A.Point
>fromCarth : () => A.Point
>A : unknown
>Point : A.Point
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 15, 3), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 16, 3))
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 15, 8))
>y : number, Symbol(y, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 15, 19))
>toCarth : () => A.Point, Symbol(toCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 15, 30))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
>fromCarth : () => A.Point, Symbol(fromCarth, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 15, 50))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
var p: A.Point;
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
>A : unknown
>Point : A.Point
>p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }, Symbol(p, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 15, 3), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 16, 3))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
module X.Y.Z {
>X : unknown
>Y : unknown
>Z : unknown
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 16, 15), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 22, 1))
>Y : any, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 9), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 24, 10))
>Z : any, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 11), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 25, 20))
export interface Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 14), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 25, 23))
new (start: A.Point, end: A.Point);
>start : A.Point
>A : unknown
>Point : A.Point
>end : A.Point
>A : unknown
>Point : A.Point
>start : A.Point, Symbol(start, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 20, 13))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
>end : A.Point, Symbol(end, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 20, 28))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
}
}
module X {
>X : unknown
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 16, 15), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 22, 1))
export module Y.Z {
>Y : unknown
>Z : unknown
>Y : any, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 9), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 24, 10))
>Z : any, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 11), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 25, 20))
export interface Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 14), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 25, 23))
start: A.Point;
>start : A.Point
>A : unknown
>Point : A.Point
>start : A.Point, Symbol(start, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 26, 31))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
end: A.Point;
>end : A.Point
>A : unknown
>Point : A.Point
>end : A.Point, Symbol(end, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 27, 27))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
}
}
}
// ensure merges as expected
var l: { start: A.Point; end: A.Point; new (s: A.Point, e: A.Point); }
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
>start : A.Point
>A : unknown
>Point : A.Point
>end : A.Point
>A : unknown
>Point : A.Point
>s : A.Point
>A : unknown
>Point : A.Point
>e : A.Point
>A : unknown
>Point : A.Point
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 34, 3), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 35, 3))
>start : A.Point, Symbol(start, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 34, 8))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
>end : A.Point, Symbol(end, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 34, 24))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
>s : A.Point, Symbol(s, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 34, 44))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
>e : A.Point, Symbol(e, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 34, 55))
>A : any, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 6, 1))
>Point : A.Point, Symbol(A.Point, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 0, 10), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 8, 10))
var l: X.Y.Z.Line;
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 34, 3), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 35, 3))
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 16, 15), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 22, 1))
>Y : any, Symbol(X.Y, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 9), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 24, 10))
>Z : any, Symbol(X.Y.Z, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 11), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 25, 20))
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line, Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 18, 14), Decl(TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts, 25, 23))

60
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.types
View File

@ -1,62 +1,62 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts ===
module A.B {
>A : typeof A
>B : typeof B
>A : typeof A, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 2, 1))
>B : typeof B, Symbol(B, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 0, 9))
export var x: number;
>x : number
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 1, 14))
}
module A{
>A : typeof A
>A : typeof A, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 2, 1))
module B {
>B : typeof B
>B : typeof B, Symbol(B, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 4, 9))
export var x: string;
>x : string
>x : string, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 6, 18))
}
}
// ensure the right var decl is exported
var x: number;
>x : number
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 11, 3), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 12, 3))
var x = A.B.x;
>x : number
>A.B.x : number
>A.B : typeof A.B
>A : typeof A
>B : typeof A.B
>x : number
>x : number, Symbol(x, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 11, 3), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 12, 3))
>A.B.x : number, Symbol(A.B.x, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 1, 14))
>A.B : typeof A.B, Symbol(A.B, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 0, 9))
>A : typeof A, Symbol(A, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 0, 0), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 2, 1))
>B : typeof A.B, Symbol(A.B, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 0, 9))
>x : number, Symbol(A.B.x, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 1, 14))
module X.Y.Z {
>X : typeof X
>Y : typeof Y
>Z : typeof Z
>X : typeof X, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 12, 14), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 18, 1))
>Y : typeof Y, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 9), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 20, 10))
>Z : typeof Z, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 11))
export class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 14))
length: number;
>length : number
>length : number, Symbol(length, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 15, 23))
}
}
module X {
>X : typeof X
>X : typeof X, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 12, 14), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 18, 1))
export module Y {
>Y : typeof Y
>Y : typeof Y, Symbol(Y, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 9), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 20, 10))
module Z {
>Z : typeof Z
>Z : typeof Z, Symbol(Z, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 21, 21))
export class Line {
>Line : Line
>Line : Line, Symbol(Line, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 22, 18))
name: string;
>name : string
>name : string, Symbol(name, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 23, 31))
}
}
}
@ -64,13 +64,13 @@ module X {
// make sure merging works as expected
var l: { length: number };
>l : { length: number; }
>length : number
>l : { length: number; }, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 31, 3), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 32, 3))
>length : number, Symbol(length, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 31, 8))
var l: X.Y.Z.Line;
>l : { length: number; }
>X : unknown
>Y : unknown
>Z : unknown
>Line : X.Y.Z.Line
>l : { length: number; }, Symbol(l, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 31, 3), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 32, 3))
>X : any, Symbol(X, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 12, 14), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 18, 1))
>Y : any, Symbol(X.Y, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 9), Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 20, 10))
>Z : any, Symbol(X.Y.Z, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 11))
>Line : X.Y.Z.Line, Symbol(X.Y.Z.Line, Decl(TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts, 14, 14))

76
tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types
View File

@ -1,40 +1,40 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
module Root {
>Root : typeof Root
>Root : typeof Root, Symbol(Root, Decl(part1.ts, 0, 0))
export module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 13))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(part1.ts, 1, 21))
x: number;
>x : number
>x : number, Symbol(x, Decl(part1.ts, 2, 32))
y: number;
>y : number
>y : number, Symbol(y, Decl(part1.ts, 3, 22))
}
export module Utils {
>Utils : typeof Utils
>Utils : typeof Utils, Symbol(Utils, Decl(part1.ts, 5, 9))
export function mirror<T extends Point>(p: T) {
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>T : T
>Point : Point
>p : T
>T : T
>mirror : <T extends Point>(p: T) => { x: number; y: number; }, Symbol(mirror, Decl(part1.ts, 7, 29))
>T : T, Symbol(T, Decl(part1.ts, 8, 35))
>Point : Point, Symbol(Point, Decl(part1.ts, 1, 21))
>p : T, Symbol(p, Decl(part1.ts, 8, 52))
>T : T, Symbol(T, Decl(part1.ts, 8, 35))
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
>x : number, Symbol(x, Decl(part1.ts, 9, 24))
>p.y : number, Symbol(Point.y, Decl(part1.ts, 3, 22))
>p : T, Symbol(p, Decl(part1.ts, 8, 52))
>y : number, Symbol(Point.y, Decl(part1.ts, 3, 22))
>y : number, Symbol(y, Decl(part1.ts, 9, 32))
>p.x : number, Symbol(Point.x, Decl(part1.ts, 2, 32))
>p : T, Symbol(p, Decl(part1.ts, 8, 52))
>x : number, Symbol(Point.x, Decl(part1.ts, 2, 32))
}
}
}
@ -42,36 +42,38 @@ module Root {
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
module otherRoot {
>otherRoot : typeof otherRoot
>otherRoot : typeof otherRoot, Symbol(otherRoot, Decl(part2.ts, 0, 0))
export module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(part2.ts, 0, 18))
// have to be fully qualified since in different root
export var Origin: Root.A.Point = { x: 0, y: 0 };
>Origin : Root.A.Point
>Root : unknown
>A : unknown
>Point : Root.A.Point
>Origin : Root.A.Point, Symbol(Origin, Decl(part2.ts, 3, 18))
>Root : any, Symbol(Root, Decl(part1.ts, 0, 0))
>A : any, Symbol(Root.A, Decl(part1.ts, 0, 13))
>Point : Root.A.Point, Symbol(Root.A.Point, Decl(part1.ts, 1, 21))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(part2.ts, 3, 43))
>0 : number
>y : number, Symbol(y, Decl(part2.ts, 3, 49))
>0 : number
export module Utils {
>Utils : typeof Utils
>Utils : typeof Utils, Symbol(Utils, Decl(part2.ts, 3, 57))
export class Plane {
>Plane : Plane
>Plane : Plane, Symbol(Plane, Decl(part2.ts, 5, 29))
constructor(public tl: Root.A.Point, public br: Root.A.Point) { }
>tl : Root.A.Point
>Root : unknown
>A : unknown
>Point : Root.A.Point
>br : Root.A.Point
>Root : unknown
>A : unknown
>Point : Root.A.Point
>tl : Root.A.Point, Symbol(tl, Decl(part2.ts, 7, 28))
>Root : any, Symbol(Root, Decl(part1.ts, 0, 0))
>A : any, Symbol(Root.A, Decl(part1.ts, 0, 13))
>Point : Root.A.Point, Symbol(Root.A.Point, Decl(part1.ts, 1, 21))
>br : Root.A.Point, Symbol(br, Decl(part2.ts, 7, 52))
>Root : any, Symbol(Root, Decl(part1.ts, 0, 0))
>A : any, Symbol(Root.A, Decl(part1.ts, 0, 13))
>Point : Root.A.Point, Symbol(Root.A.Point, Decl(part1.ts, 1, 21))
}
}
}

136
tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types
View File

@ -1,63 +1,65 @@
=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
export interface Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
x: number;
>x : number
>x : number, Symbol(x, Decl(part1.ts, 1, 28))
y: number;
>y : number
>y : number, Symbol(y, Decl(part1.ts, 2, 18))
}
export module Utils {
>Utils : typeof Utils
>Utils : typeof Utils, Symbol(Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
export function mirror<T extends Point>(p: T) {
>mirror : <T extends Point>(p: T) => { x: number; y: number; }
>T : T
>Point : Point
>p : T
>T : T
>mirror : <T extends Point>(p: T) => { x: number; y: number; }, Symbol(mirror, Decl(part1.ts, 6, 25))
>T : T, Symbol(T, Decl(part1.ts, 7, 31))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
>p : T, Symbol(p, Decl(part1.ts, 7, 48))
>T : T, Symbol(T, Decl(part1.ts, 7, 31))
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
>x : number, Symbol(x, Decl(part1.ts, 8, 20))
>p.y : number, Symbol(Point.y, Decl(part1.ts, 2, 18))
>p : T, Symbol(p, Decl(part1.ts, 7, 48))
>y : number, Symbol(Point.y, Decl(part1.ts, 2, 18))
>y : number, Symbol(y, Decl(part1.ts, 8, 28))
>p.x : number, Symbol(Point.x, Decl(part1.ts, 1, 28))
>p : T, Symbol(p, Decl(part1.ts, 7, 48))
>x : number, Symbol(Point.x, Decl(part1.ts, 1, 28))
}
}
}
=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
module A {
>A : typeof A
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
export var Origin: Point = { x: 0, y: 0 };
>Origin : Point
>Point : Point
>Origin : Point, Symbol(Origin, Decl(part2.ts, 1, 14))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
>{ x: 0, y: 0 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(part2.ts, 1, 32))
>0 : number
>y : number, Symbol(y, Decl(part2.ts, 1, 38))
>0 : number
export module Utils {
>Utils : typeof Utils
>Utils : typeof Utils, Symbol(Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
export class Plane {
>Plane : Plane
>Plane : Plane, Symbol(Plane, Decl(part2.ts, 3, 25))
constructor(public tl: Point, public br: Point) { }
>tl : Point
>Point : Point
>br : Point
>Point : Point
>tl : Point, Symbol(tl, Decl(part2.ts, 5, 24))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
>br : Point, Symbol(br, Decl(part2.ts, 5, 41))
>Point : Point, Symbol(Point, Decl(part1.ts, 0, 10))
}
}
}
@ -66,57 +68,59 @@ module A {
// test the merging actually worked
var o: { x: number; y: number };
>o : { x: number; y: number; }
>x : number
>y : number
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>x : number, Symbol(x, Decl(part3.ts, 2, 8))
>y : number, Symbol(y, Decl(part3.ts, 2, 19))
var o: A.Point;
>o : { x: number; y: number; }
>A : unknown
>Point : A.Point
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Point : A.Point, Symbol(A.Point, Decl(part1.ts, 0, 10))
var o = A.Origin;
>o : { x: number; y: number; }
>A.Origin : A.Point
>A : typeof A
>Origin : A.Point
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>A.Origin : A.Point, Symbol(A.Origin, Decl(part2.ts, 1, 14))
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Origin : A.Point, Symbol(A.Origin, Decl(part2.ts, 1, 14))
var o = A.Utils.mirror(o);
>o : { x: number; y: number; }
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>A.Utils.mirror(o) : { x: number; y: number; }
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof A.Utils
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
>o : { x: number; y: number; }
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror, Decl(part1.ts, 6, 25))
>A.Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }, Symbol(A.Utils.mirror, Decl(part1.ts, 6, 25))
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
var p: { tl: A.Point; br: A.Point };
>p : { tl: A.Point; br: A.Point; }
>tl : A.Point
>A : unknown
>Point : A.Point
>br : A.Point
>A : unknown
>Point : A.Point
>p : { tl: A.Point; br: A.Point; }, Symbol(p, Decl(part3.ts, 7, 3), Decl(part3.ts, 8, 3), Decl(part3.ts, 9, 3))
>tl : A.Point, Symbol(tl, Decl(part3.ts, 7, 8))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Point : A.Point, Symbol(A.Point, Decl(part1.ts, 0, 10))
>br : A.Point, Symbol(br, Decl(part3.ts, 7, 21))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Point : A.Point, Symbol(A.Point, Decl(part1.ts, 0, 10))
var p: A.Utils.Plane;
>p : { tl: A.Point; br: A.Point; }
>A : unknown
>Utils : unknown
>Plane : A.Utils.Plane
>p : { tl: A.Point; br: A.Point; }, Symbol(p, Decl(part3.ts, 7, 3), Decl(part3.ts, 8, 3), Decl(part3.ts, 9, 3))
>A : any, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Utils : any, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
>Plane : A.Utils.Plane, Symbol(A.Utils.Plane, Decl(part2.ts, 3, 25))
var p = new A.Utils.Plane(o, { x: 1, y: 1 });
>p : { tl: A.Point; br: A.Point; }
>p : { tl: A.Point; br: A.Point; }, Symbol(p, Decl(part3.ts, 7, 3), Decl(part3.ts, 8, 3), Decl(part3.ts, 9, 3))
>new A.Utils.Plane(o, { x: 1, y: 1 }) : A.Utils.Plane
>A.Utils.Plane : typeof A.Utils.Plane
>A.Utils : typeof A.Utils
>A : typeof A
>Utils : typeof A.Utils
>Plane : typeof A.Utils.Plane
>o : { x: number; y: number; }
>A.Utils.Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane, Decl(part2.ts, 3, 25))
>A.Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
>A : typeof A, Symbol(A, Decl(part1.ts, 0, 0), Decl(part2.ts, 0, 0))
>Utils : typeof A.Utils, Symbol(A.Utils, Decl(part1.ts, 4, 5), Decl(part2.ts, 1, 46))
>Plane : typeof A.Utils.Plane, Symbol(A.Utils.Plane, Decl(part2.ts, 3, 25))
>o : { x: number; y: number; }, Symbol(o, Decl(part3.ts, 2, 3), Decl(part3.ts, 3, 3), Decl(part3.ts, 4, 3), Decl(part3.ts, 5, 3))
>{ x: 1, y: 1 } : { x: number; y: number; }
>x : number
>y : number
>x : number, Symbol(x, Decl(part3.ts, 9, 30))
>1 : number
>y : number, Symbol(y, Decl(part3.ts, 9, 36))
>1 : number

22
tests/baselines/reference/TypeGuardWithArrayUnion.types
View File

@ -1,26 +1,26 @@
=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithArrayUnion.ts ===
class Message {
>Message : Message
>Message : Message, Symbol(Message, Decl(TypeGuardWithArrayUnion.ts, 0, 0))
value: string;
>value : string
>value : string, Symbol(value, Decl(TypeGuardWithArrayUnion.ts, 0, 15))
}
function saySize(message: Message | Message[]) {
>saySize : (message: Message | Message[]) => number
>message : Message | Message[]
>Message : Message
>Message : Message
>saySize : (message: Message | Message[]) => number, Symbol(saySize, Decl(TypeGuardWithArrayUnion.ts, 2, 1))
>message : Message | Message[], Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17))
>Message : Message, Symbol(Message, Decl(TypeGuardWithArrayUnion.ts, 0, 0))
>Message : Message, Symbol(Message, Decl(TypeGuardWithArrayUnion.ts, 0, 0))
if (message instanceof Array) {
>message instanceof Array : boolean
>message : Message | Message[]
>Array : ArrayConstructor
>message : Message | Message[], Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17))
>Array : ArrayConstructor, Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
return message.length; // Should have type Message[] here
>message.length : number
>message : Message[]
>length : number
>message.length : number, Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
>message : Message[], Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17))
>length : number, Symbol(Array.length, Decl(lib.d.ts, 1007, 20))
}
}

80
tests/baselines/reference/TypeGuardWithEnumUnion.types
View File

@ -1,96 +1,100 @@
=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithEnumUnion.ts ===
enum Color { R, G, B }
>Color : Color
>R : Color
>G : Color
>B : Color
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
>R : Color, Symbol(Color.R, Decl(TypeGuardWithEnumUnion.ts, 0, 12))
>G : Color, Symbol(Color.G, Decl(TypeGuardWithEnumUnion.ts, 0, 15))
>B : Color, Symbol(Color.B, Decl(TypeGuardWithEnumUnion.ts, 0, 18))
function f1(x: Color | string) {
>f1 : (x: string | Color) => void
>x : string | Color
>Color : Color
>f1 : (x: string | Color) => void, Symbol(f1, Decl(TypeGuardWithEnumUnion.ts, 0, 22))
>x : string | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>x : string | Color
>x : string | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
>"number" : string
var y = x;
>y : Color
>x : Color
>y : Color, Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 4, 11), Decl(TypeGuardWithEnumUnion.ts, 5, 11))
>x : Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
var y: Color;
>y : Color
>Color : Color
>y : Color, Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 4, 11), Decl(TypeGuardWithEnumUnion.ts, 5, 11))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
}
else {
var z = x;
>z : string
>x : string
>z : string, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 8, 11), Decl(TypeGuardWithEnumUnion.ts, 9, 11))
>x : string, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
var z: string;
>z : string
>z : string, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 8, 11), Decl(TypeGuardWithEnumUnion.ts, 9, 11))
}
}
function f2(x: Color | string | string[]) {
>f2 : (x: string | string[] | Color) => void
>x : string | string[] | Color
>Color : Color
>f2 : (x: string | string[] | Color) => void, Symbol(f2, Decl(TypeGuardWithEnumUnion.ts, 11, 1))
>x : string | string[] | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
if (typeof x === "object") {
>typeof x === "object" : boolean
>typeof x : string
>x : string | string[] | Color
>x : string | string[] | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>"object" : string
var y = x;
>y : string[]
>x : string[]
>y : string[], Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 15, 11), Decl(TypeGuardWithEnumUnion.ts, 16, 11))
>x : string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var y: string[];
>y : string[]
>y : string[], Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 15, 11), Decl(TypeGuardWithEnumUnion.ts, 16, 11))
}
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>x : string | string[] | Color
>x : string | string[] | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>"number" : string
var z = x;
>z : Color
>x : Color
>z : Color, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 19, 11), Decl(TypeGuardWithEnumUnion.ts, 20, 11))
>x : Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var z: Color;
>z : Color
>Color : Color
>z : Color, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 19, 11), Decl(TypeGuardWithEnumUnion.ts, 20, 11))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
}
else {
var w = x;
>w : string | string[]
>x : string | string[]
>w : string | string[], Symbol(w, Decl(TypeGuardWithEnumUnion.ts, 23, 11), Decl(TypeGuardWithEnumUnion.ts, 24, 11))
>x : string | string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var w: string | string[];
>w : string | string[]
>w : string | string[], Symbol(w, Decl(TypeGuardWithEnumUnion.ts, 23, 11), Decl(TypeGuardWithEnumUnion.ts, 24, 11))
}
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : string | string[] | Color
>x : string | string[] | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>"string" : string
var a = x;
>a : string
>x : string
>a : string, Symbol(a, Decl(TypeGuardWithEnumUnion.ts, 27, 11), Decl(TypeGuardWithEnumUnion.ts, 28, 11))
>x : string, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var a: string;
>a : string
>a : string, Symbol(a, Decl(TypeGuardWithEnumUnion.ts, 27, 11), Decl(TypeGuardWithEnumUnion.ts, 28, 11))
}
else {
var b = x;
>b : string[] | Color
>x : string[] | Color
>b : string[] | Color, Symbol(b, Decl(TypeGuardWithEnumUnion.ts, 31, 11), Decl(TypeGuardWithEnumUnion.ts, 32, 11))
>x : string[] | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var b: Color | string[];
>b : string[] | Color
>Color : Color
>b : string[] | Color, Symbol(b, Decl(TypeGuardWithEnumUnion.ts, 31, 11), Decl(TypeGuardWithEnumUnion.ts, 32, 11))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
}
}

80
tests/baselines/reference/TypeGuardWithEnumUnion.types.pull
View File

@ -1,96 +1,100 @@
=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithEnumUnion.ts ===
enum Color { R, G, B }
>Color : Color
>R : Color
>G : Color
>B : Color
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
>R : Color, Symbol(Color.R, Decl(TypeGuardWithEnumUnion.ts, 0, 12))
>G : Color, Symbol(Color.G, Decl(TypeGuardWithEnumUnion.ts, 0, 15))
>B : Color, Symbol(Color.B, Decl(TypeGuardWithEnumUnion.ts, 0, 18))
function f1(x: Color | string) {
>f1 : (x: string | Color) => void
>x : string | Color
>Color : Color
>f1 : (x: string | Color) => void, Symbol(f1, Decl(TypeGuardWithEnumUnion.ts, 0, 22))
>x : string | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>x : string | Color
>x : string | Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
>"number" : string
var y = x;
>y : Color
>x : Color
>y : Color, Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 4, 11), Decl(TypeGuardWithEnumUnion.ts, 5, 11))
>x : Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
var y: Color;
>y : Color
>Color : Color
>y : Color, Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 4, 11), Decl(TypeGuardWithEnumUnion.ts, 5, 11))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
}
else {
var z = x;
>z : string
>x : string
>z : string, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 8, 11), Decl(TypeGuardWithEnumUnion.ts, 9, 11))
>x : string, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 2, 12))
var z: string;
>z : string
>z : string, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 8, 11), Decl(TypeGuardWithEnumUnion.ts, 9, 11))
}
}
function f2(x: Color | string | string[]) {
>f2 : (x: string | Color | string[]) => void
>x : string | Color | string[]
>Color : Color
>f2 : (x: string | Color | string[]) => void, Symbol(f2, Decl(TypeGuardWithEnumUnion.ts, 11, 1))
>x : string | Color | string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
if (typeof x === "object") {
>typeof x === "object" : boolean
>typeof x : string
>x : string | Color | string[]
>x : string | Color | string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>"object" : string
var y = x;
>y : string[]
>x : string[]
>y : string[], Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 15, 11), Decl(TypeGuardWithEnumUnion.ts, 16, 11))
>x : string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var y: string[];
>y : string[]
>y : string[], Symbol(y, Decl(TypeGuardWithEnumUnion.ts, 15, 11), Decl(TypeGuardWithEnumUnion.ts, 16, 11))
}
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>x : string | Color | string[]
>x : string | Color | string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>"number" : string
var z = x;
>z : Color
>x : Color
>z : Color, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 19, 11), Decl(TypeGuardWithEnumUnion.ts, 20, 11))
>x : Color, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var z: Color;
>z : Color
>Color : Color
>z : Color, Symbol(z, Decl(TypeGuardWithEnumUnion.ts, 19, 11), Decl(TypeGuardWithEnumUnion.ts, 20, 11))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
}
else {
var w = x;
>w : string | string[]
>x : string | string[]
>w : string | string[], Symbol(w, Decl(TypeGuardWithEnumUnion.ts, 23, 11), Decl(TypeGuardWithEnumUnion.ts, 24, 11))
>x : string | string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var w: string | string[];
>w : string | string[]
>w : string | string[], Symbol(w, Decl(TypeGuardWithEnumUnion.ts, 23, 11), Decl(TypeGuardWithEnumUnion.ts, 24, 11))
}
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : string | Color | string[]
>x : string | Color | string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
>"string" : string
var a = x;
>a : string
>x : string
>a : string, Symbol(a, Decl(TypeGuardWithEnumUnion.ts, 27, 11), Decl(TypeGuardWithEnumUnion.ts, 28, 11))
>x : string, Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var a: string;
>a : string
>a : string, Symbol(a, Decl(TypeGuardWithEnumUnion.ts, 27, 11), Decl(TypeGuardWithEnumUnion.ts, 28, 11))
}
else {
var b = x;
>b : Color | string[]
>x : Color | string[]
>b : Color | string[], Symbol(b, Decl(TypeGuardWithEnumUnion.ts, 31, 11), Decl(TypeGuardWithEnumUnion.ts, 32, 11))
>x : Color | string[], Symbol(x, Decl(TypeGuardWithEnumUnion.ts, 13, 12))
var b: Color | string[];
>b : Color | string[]
>Color : Color
>b : Color | string[], Symbol(b, Decl(TypeGuardWithEnumUnion.ts, 31, 11), Decl(TypeGuardWithEnumUnion.ts, 32, 11))
>Color : Color, Symbol(Color, Decl(TypeGuardWithEnumUnion.ts, 0, 0))
}
}

3
tests/baselines/reference/VariableDeclaration10_es6.types
View File

@ -1,4 +1,5 @@
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration10_es6.ts ===
let a: number = 1
>a : number
>a : number, Symbol(a, Decl(VariableDeclaration10_es6.ts, 0, 3))
>1 : number

3
tests/baselines/reference/VariableDeclaration3_es6.types
View File

@ -1,4 +1,5 @@
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration3_es6.ts ===
const a = 1
>a : number
>a : number, Symbol(a, Decl(VariableDeclaration3_es6.ts, 0, 5))
>1 : number

3
tests/baselines/reference/VariableDeclaration5_es6.types
View File

@ -1,4 +1,5 @@
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration5_es6.ts ===
const a: number = 1
>a : number
>a : number, Symbol(a, Decl(VariableDeclaration5_es6.ts, 0, 5))
>1 : number

2
tests/baselines/reference/VariableDeclaration7_es6.types
View File

@ -1,4 +1,4 @@
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration7_es6.ts ===
let a
>a : any
>a : any, Symbol(a, Decl(VariableDeclaration7_es6.ts, 0, 3))

3
tests/baselines/reference/VariableDeclaration8_es6.types
View File

@ -1,4 +1,5 @@
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration8_es6.ts ===
let a = 1
>a : number
>a : number, Symbol(a, Decl(VariableDeclaration8_es6.ts, 0, 3))
>1 : number

2
tests/baselines/reference/VariableDeclaration9_es6.types
View File

@ -1,4 +1,4 @@
=== tests/cases/conformance/es6/variableDeclarations/VariableDeclaration9_es6.ts ===
let a: number
>a : number
>a : number, Symbol(a, Decl(VariableDeclaration9_es6.ts, 0, 3))

14
tests/baselines/reference/acceptableAlias1.types
View File

@ -1,17 +1,17 @@
=== tests/cases/compiler/acceptableAlias1.ts ===
module M {
>M : typeof M
>M : typeof M, Symbol(M, Decl(acceptableAlias1.ts, 0, 0))
export module N {
>N : unknown
>N : any, Symbol(N, Decl(acceptableAlias1.ts, 0, 10))
}
export import X = N;
>X : unknown
>N : unknown
>X : any, Symbol(X, Decl(acceptableAlias1.ts, 2, 5))
>N : any, Symbol(N, Decl(acceptableAlias1.ts, 0, 10))
}
import r = M.X;
>r : unknown
>M : typeof M
>X : unknown
>r : any, Symbol(r, Decl(acceptableAlias1.ts, 4, 1))
>M : typeof M, Symbol(M, Decl(acceptableAlias1.ts, 0, 0))
>X : any, Symbol(r, Decl(acceptableAlias1.ts, 0, 10))

53
tests/baselines/reference/accessOverriddenBaseClassMember1.types
View File

@ -1,54 +1,57 @@
=== tests/cases/compiler/accessOverriddenBaseClassMember1.ts ===
class Point {
>Point : Point
>Point : Point, Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
constructor(public x: number, public y: number) { }
>x : number
>y : number
>x : number, Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
>y : number, Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
public toString() {
>toString : () => string
>toString : () => string, Symbol(toString, Decl(accessOverriddenBaseClassMember1.ts, 1, 55))
return "x=" + this.x + " y=" + this.y;
>"x=" + this.x + " y=" + this.y : string
>"x=" + this.x + " y=" : string
>"x=" + this.x : string
>this.x : number
>this : Point
>x : number
>this.y : number
>this : Point
>y : number
>"x=" : string
>this.x : number, Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
>this : Point, Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
>x : number, Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 1, 16))
>" y=" : string
>this.y : number, Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
>this : Point, Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
>y : number, Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 1, 33))
}
}
class ColoredPoint extends Point {
>ColoredPoint : ColoredPoint
>Point : Point
>ColoredPoint : ColoredPoint, Symbol(ColoredPoint, Decl(accessOverriddenBaseClassMember1.ts, 5, 1))
>Point : Point, Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
constructor(x: number, y: number, public color: string) {
>x : number
>y : number
>color : string
>x : number, Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 7, 16))
>y : number, Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 7, 26))
>color : string, Symbol(color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
super(x, y);
>super(x, y) : void
>super : typeof Point
>x : number
>y : number
>super : typeof Point, Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
>x : number, Symbol(x, Decl(accessOverriddenBaseClassMember1.ts, 7, 16))
>y : number, Symbol(y, Decl(accessOverriddenBaseClassMember1.ts, 7, 26))
}
public toString() {
>toString : () => string
>toString : () => string, Symbol(toString, Decl(accessOverriddenBaseClassMember1.ts, 9, 5))
return super.toString() + " color=" + this.color;
>super.toString() + " color=" + this.color : string
>super.toString() + " color=" : string
>super.toString() : string
>super.toString : () => string
>super : Point
>toString : () => string
>this.color : string
>this : ColoredPoint
>color : string
>super.toString : () => string, Symbol(Point.toString, Decl(accessOverriddenBaseClassMember1.ts, 1, 55))
>super : Point, Symbol(Point, Decl(accessOverriddenBaseClassMember1.ts, 0, 0))
>toString : () => string, Symbol(Point.toString, Decl(accessOverriddenBaseClassMember1.ts, 1, 55))
>" color=" : string
>this.color : string, Symbol(color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
>this : ColoredPoint, Symbol(ColoredPoint, Decl(accessOverriddenBaseClassMember1.ts, 5, 1))
>color : string, Symbol(color, Decl(accessOverriddenBaseClassMember1.ts, 7, 37))
}
}

22
tests/baselines/reference/accessorWithES5.types
View File

@ -1,37 +1,39 @@
=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts ===
class C {
>C : C
>C : C, Symbol(C, Decl(accessorWithES5.ts, 0, 0))
get x() {
>x : number
>x : number, Symbol(x, Decl(accessorWithES5.ts, 1, 9))
return 1;
>1 : number
}
}
class D {
>D : D
>D : D, Symbol(D, Decl(accessorWithES5.ts, 5, 1))
set x(v) {
>x : any
>v : any
>x : any, Symbol(x, Decl(accessorWithES5.ts, 7, 9))
>v : any, Symbol(v, Decl(accessorWithES5.ts, 8, 10))
}
}
var x = {
>x : { a: number; }
>x : { a: number; }, Symbol(x, Decl(accessorWithES5.ts, 12, 3))
>{ get a() { return 1 }} : { a: number; }
get a() { return 1 }
>a : number
>a : number, Symbol(a, Decl(accessorWithES5.ts, 12, 9))
>1 : number
}
var y = {
>y : { b: any; }
>y : { b: any; }, Symbol(y, Decl(accessorWithES5.ts, 16, 3))
>{ set b(v) { }} : { b: any; }
set b(v) { }
>b : any
>v : any
>b : any, Symbol(b, Decl(accessorWithES5.ts, 16, 9))
>v : any, Symbol(v, Decl(accessorWithES5.ts, 17, 10))
}

16
tests/baselines/reference/addMoreCallSignaturesToBaseSignature.types
View File

@ -1,24 +1,24 @@
=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature.ts ===
interface Foo {
>Foo : Foo
>Foo : Foo, Symbol(Foo, Decl(addMoreCallSignaturesToBaseSignature.ts, 0, 0))
(): string;
}
interface Bar extends Foo {
>Bar : Bar
>Foo : Foo
>Bar : Bar, Symbol(Bar, Decl(addMoreCallSignaturesToBaseSignature.ts, 2, 1))
>Foo : Foo, Symbol(Foo, Decl(addMoreCallSignaturesToBaseSignature.ts, 0, 0))
(key: string): string;
>key : string
>key : string, Symbol(key, Decl(addMoreCallSignaturesToBaseSignature.ts, 5, 5))
}
var a: Bar;
>a : Bar
>Bar : Bar
>a : Bar, Symbol(a, Decl(addMoreCallSignaturesToBaseSignature.ts, 8, 3))
>Bar : Bar, Symbol(Bar, Decl(addMoreCallSignaturesToBaseSignature.ts, 2, 1))
var kitty = a();
>kitty : string
>kitty : string, Symbol(kitty, Decl(addMoreCallSignaturesToBaseSignature.ts, 9, 3))
>a() : string
>a : Bar
>a : Bar, Symbol(a, Decl(addMoreCallSignaturesToBaseSignature.ts, 8, 3))

19
tests/baselines/reference/addMoreCallSignaturesToBaseSignature2.types
View File

@ -1,25 +1,26 @@
=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature2.ts ===
interface Foo {
>Foo : Foo
>Foo : Foo, Symbol(Foo, Decl(addMoreCallSignaturesToBaseSignature2.ts, 0, 0))
(bar:number): string;
>bar : number
>bar : number, Symbol(bar, Decl(addMoreCallSignaturesToBaseSignature2.ts, 1, 5))
}
interface Bar extends Foo {
>Bar : Bar
>Foo : Foo
>Bar : Bar, Symbol(Bar, Decl(addMoreCallSignaturesToBaseSignature2.ts, 2, 1))
>Foo : Foo, Symbol(Foo, Decl(addMoreCallSignaturesToBaseSignature2.ts, 0, 0))
(key: string): string;
>key : string
>key : string, Symbol(key, Decl(addMoreCallSignaturesToBaseSignature2.ts, 5, 5))
}
var a: Bar;
>a : Bar
>Bar : Bar
>a : Bar, Symbol(a, Decl(addMoreCallSignaturesToBaseSignature2.ts, 8, 3))
>Bar : Bar, Symbol(Bar, Decl(addMoreCallSignaturesToBaseSignature2.ts, 2, 1))
var kitty = a(1);
>kitty : string
>kitty : string, Symbol(kitty, Decl(addMoreCallSignaturesToBaseSignature2.ts, 9, 3))
>a(1) : string
>a : Bar
>a : Bar, Symbol(a, Decl(addMoreCallSignaturesToBaseSignature2.ts, 8, 3))
>1 : number

157
tests/baselines/reference/additionOperatorWithAnyAndEveryType.types
View File

@ -1,168 +1,171 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithAnyAndEveryType.ts ===
function foo() { }
>foo : () => void
>foo : () => void, Symbol(foo, Decl(additionOperatorWithAnyAndEveryType.ts, 0, 0))
class C {
>C : C
>C : C, Symbol(C, Decl(additionOperatorWithAnyAndEveryType.ts, 0, 18))
public a: string;
>a : string
>a : string, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 1, 9))
static foo() { }
>foo : () => void
>foo : () => void, Symbol(C.foo, Decl(additionOperatorWithAnyAndEveryType.ts, 2, 21))
}
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
>E : E, Symbol(E, Decl(additionOperatorWithAnyAndEveryType.ts, 4, 1))
>a : E, Symbol(E.a, Decl(additionOperatorWithAnyAndEveryType.ts, 5, 8))
>b : E, Symbol(E.b, Decl(additionOperatorWithAnyAndEveryType.ts, 5, 11))
>c : E, Symbol(E.c, Decl(additionOperatorWithAnyAndEveryType.ts, 5, 14))
module M { export var a }
>M : typeof M
>a : any
>M : typeof M, Symbol(M, Decl(additionOperatorWithAnyAndEveryType.ts, 5, 18))
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 6, 21))
var a: any;
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
var b: boolean;
>b : boolean
>b : boolean, Symbol(b, Decl(additionOperatorWithAnyAndEveryType.ts, 9, 3))
var c: number;
>c : number
>c : number, Symbol(c, Decl(additionOperatorWithAnyAndEveryType.ts, 10, 3))
var d: string;
>d : string
>d : string, Symbol(d, Decl(additionOperatorWithAnyAndEveryType.ts, 11, 3))
var e: Object;
>e : Object
>Object : Object
>e : Object, Symbol(e, Decl(additionOperatorWithAnyAndEveryType.ts, 12, 3))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
// any as left operand, result is type Any except plusing string
var r1 = a + a;
>r1 : any
>r1 : any, Symbol(r1, Decl(additionOperatorWithAnyAndEveryType.ts, 15, 3))
>a + a : any
>a : any
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
var r2 = a + b;
>r2 : any
>r2 : any, Symbol(r2, Decl(additionOperatorWithAnyAndEveryType.ts, 16, 3))
>a + b : any
>a : any
>b : boolean
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>b : boolean, Symbol(b, Decl(additionOperatorWithAnyAndEveryType.ts, 9, 3))
var r3 = a + c;
>r3 : any
>r3 : any, Symbol(r3, Decl(additionOperatorWithAnyAndEveryType.ts, 17, 3))
>a + c : any
>a : any
>c : number
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>c : number, Symbol(c, Decl(additionOperatorWithAnyAndEveryType.ts, 10, 3))
var r4 = a + d;
>r4 : string
>r4 : string, Symbol(r4, Decl(additionOperatorWithAnyAndEveryType.ts, 18, 3))
>a + d : string
>a : any
>d : string
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>d : string, Symbol(d, Decl(additionOperatorWithAnyAndEveryType.ts, 11, 3))
var r5 = a + e;
>r5 : any
>r5 : any, Symbol(r5, Decl(additionOperatorWithAnyAndEveryType.ts, 19, 3))
>a + e : any
>a : any
>e : Object
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>e : Object, Symbol(e, Decl(additionOperatorWithAnyAndEveryType.ts, 12, 3))
// any as right operand, result is type Any except plusing string
var r6 = b + a;
>r6 : any
>r6 : any, Symbol(r6, Decl(additionOperatorWithAnyAndEveryType.ts, 22, 3))
>b + a : any
>b : boolean
>a : any
>b : boolean, Symbol(b, Decl(additionOperatorWithAnyAndEveryType.ts, 9, 3))
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
var r7 = c + a;
>r7 : any
>r7 : any, Symbol(r7, Decl(additionOperatorWithAnyAndEveryType.ts, 23, 3))
>c + a : any
>c : number
>a : any
>c : number, Symbol(c, Decl(additionOperatorWithAnyAndEveryType.ts, 10, 3))
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
var r8 = d + a;
>r8 : string
>r8 : string, Symbol(r8, Decl(additionOperatorWithAnyAndEveryType.ts, 24, 3))
>d + a : string
>d : string
>a : any
>d : string, Symbol(d, Decl(additionOperatorWithAnyAndEveryType.ts, 11, 3))
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
var r9 = e + a;
>r9 : any
>r9 : any, Symbol(r9, Decl(additionOperatorWithAnyAndEveryType.ts, 25, 3))
>e + a : any
>e : Object
>a : any
>e : Object, Symbol(e, Decl(additionOperatorWithAnyAndEveryType.ts, 12, 3))
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
// other cases
var r10 = a + foo;
>r10 : any
>r10 : any, Symbol(r10, Decl(additionOperatorWithAnyAndEveryType.ts, 28, 3))
>a + foo : any
>a : any
>foo : () => void
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>foo : () => void, Symbol(foo, Decl(additionOperatorWithAnyAndEveryType.ts, 0, 0))
var r11 = a + foo();
>r11 : any
>r11 : any, Symbol(r11, Decl(additionOperatorWithAnyAndEveryType.ts, 29, 3))
>a + foo() : any
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>foo() : void
>foo : () => void
>foo : () => void, Symbol(foo, Decl(additionOperatorWithAnyAndEveryType.ts, 0, 0))
var r12 = a + C;
>r12 : any
>r12 : any, Symbol(r12, Decl(additionOperatorWithAnyAndEveryType.ts, 30, 3))
>a + C : any
>a : any
>C : typeof C
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>C : typeof C, Symbol(C, Decl(additionOperatorWithAnyAndEveryType.ts, 0, 18))
var r13 = a + new C();
>r13 : any
>r13 : any, Symbol(r13, Decl(additionOperatorWithAnyAndEveryType.ts, 31, 3))
>a + new C() : any
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>new C() : C
>C : typeof C
>C : typeof C, Symbol(C, Decl(additionOperatorWithAnyAndEveryType.ts, 0, 18))
var r14 = a + E;
>r14 : any
>r14 : any, Symbol(r14, Decl(additionOperatorWithAnyAndEveryType.ts, 32, 3))
>a + E : any
>a : any
>E : typeof E
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>E : typeof E, Symbol(E, Decl(additionOperatorWithAnyAndEveryType.ts, 4, 1))
var r15 = a + E.a;
>r15 : any
>r15 : any, Symbol(r15, Decl(additionOperatorWithAnyAndEveryType.ts, 33, 3))
>a + E.a : any
>a : any
>E.a : E
>E : typeof E
>a : E
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>E.a : E, Symbol(E.a, Decl(additionOperatorWithAnyAndEveryType.ts, 5, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithAnyAndEveryType.ts, 4, 1))
>a : E, Symbol(E.a, Decl(additionOperatorWithAnyAndEveryType.ts, 5, 8))
var r16 = a + M;
>r16 : any
>r16 : any, Symbol(r16, Decl(additionOperatorWithAnyAndEveryType.ts, 34, 3))
>a + M : any
>a : any
>M : typeof M
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>M : typeof M, Symbol(M, Decl(additionOperatorWithAnyAndEveryType.ts, 5, 18))
var r17 = a + '';
>r17 : string
>r17 : string, Symbol(r17, Decl(additionOperatorWithAnyAndEveryType.ts, 35, 3))
>a + '' : string
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>'' : string
var r18 = a + 123;
>r18 : any
>r18 : any, Symbol(r18, Decl(additionOperatorWithAnyAndEveryType.ts, 36, 3))
>a + 123 : any
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>123 : number
var r19 = a + { a: '' };
>r19 : any
>r19 : any, Symbol(r19, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 3))
>a + { a: '' } : any
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>{ a: '' } : { a: string; }
>a : string
>a : string, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 37, 15))
>'' : string
var r20 = a + ((a: string) => { return a });
>r20 : any
>r20 : any, Symbol(r20, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 3))
>a + ((a: string) => { return a }) : any
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 8, 3))
>((a: string) => { return a }) : (a: string) => string
>(a: string) => { return a } : (a: string) => string
>a : string
>a : string
>a : string, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 16))
>a : string, Symbol(a, Decl(additionOperatorWithAnyAndEveryType.ts, 38, 16))

104
tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types
View File

@ -2,106 +2,128 @@
// If one operand is the null or undefined value, it is treated as having the type of the other operand.
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
>E : E, Symbol(E, Decl(additionOperatorWithNullValueAndValidOperator.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 8))
>b : E, Symbol(E.b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 11))
>c : E, Symbol(E.c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 14))
var a: any;
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 3))
var b: number;
>b : number
>b : number, Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 3))
var c: E;
>c : E
>E : E
>c : E, Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 3))
>E : E, Symbol(E, Decl(additionOperatorWithNullValueAndValidOperator.ts, 0, 0))
var d: string;
>d : string
>d : string, Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 3))
// null + any
var r1: any = null + a;
>r1 : any
>r1 : any, Symbol(r1, Decl(additionOperatorWithNullValueAndValidOperator.ts, 10, 3))
>null + a : any
>a : any
>null : null
>a : any, Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 3))
var r2: any = a + null;
>r2 : any
>r2 : any, Symbol(r2, Decl(additionOperatorWithNullValueAndValidOperator.ts, 11, 3))
>a + null : any
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 4, 3))
>null : null
// null + number/enum
var r3 = null + b;
>r3 : number
>r3 : number, Symbol(r3, Decl(additionOperatorWithNullValueAndValidOperator.ts, 14, 3))
>null + b : number
>b : number
>null : null
>b : number, Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 3))
var r4 = null + 1;
>r4 : number
>r4 : number, Symbol(r4, Decl(additionOperatorWithNullValueAndValidOperator.ts, 15, 3))
>null + 1 : number
>null : null
>1 : number
var r5 = null + c;
>r5 : number
>r5 : number, Symbol(r5, Decl(additionOperatorWithNullValueAndValidOperator.ts, 16, 3))
>null + c : number
>c : E
>null : null
>c : E, Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 3))
var r6 = null + E.a;
>r6 : number
>r6 : number, Symbol(r6, Decl(additionOperatorWithNullValueAndValidOperator.ts, 17, 3))
>null + E.a : number
>E.a : E
>E : typeof E
>a : E
>null : null
>E.a : E, Symbol(E.a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithNullValueAndValidOperator.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 8))
var r7 = null + E['a'];
>r7 : number
>r7 : number, Symbol(r7, Decl(additionOperatorWithNullValueAndValidOperator.ts, 18, 3))
>null + E['a'] : number
>null : null
>E['a'] : E
>E : typeof E
>E : typeof E, Symbol(E, Decl(additionOperatorWithNullValueAndValidOperator.ts, 0, 0))
>'a' : string, Symbol(E.a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 8))
var r8 = b + null;
>r8 : number
>r8 : number, Symbol(r8, Decl(additionOperatorWithNullValueAndValidOperator.ts, 19, 3))
>b + null : number
>b : number
>b : number, Symbol(b, Decl(additionOperatorWithNullValueAndValidOperator.ts, 5, 3))
>null : null
var r9 = 1 + null;
>r9 : number
>r9 : number, Symbol(r9, Decl(additionOperatorWithNullValueAndValidOperator.ts, 20, 3))
>1 + null : number
>1 : number
>null : null
var r10 = c + null
>r10 : number
>r10 : number, Symbol(r10, Decl(additionOperatorWithNullValueAndValidOperator.ts, 21, 3))
>c + null : number
>c : E
>c : E, Symbol(c, Decl(additionOperatorWithNullValueAndValidOperator.ts, 6, 3))
>null : null
var r11 = E.a + null;
>r11 : number
>r11 : number, Symbol(r11, Decl(additionOperatorWithNullValueAndValidOperator.ts, 22, 3))
>E.a + null : number
>E.a : E
>E : typeof E
>a : E
>E.a : E, Symbol(E.a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithNullValueAndValidOperator.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 8))
>null : null
var r12 = E['a'] + null;
>r12 : number
>r12 : number, Symbol(r12, Decl(additionOperatorWithNullValueAndValidOperator.ts, 23, 3))
>E['a'] + null : number
>E['a'] : E
>E : typeof E
>E : typeof E, Symbol(E, Decl(additionOperatorWithNullValueAndValidOperator.ts, 0, 0))
>'a' : string, Symbol(E.a, Decl(additionOperatorWithNullValueAndValidOperator.ts, 2, 8))
>null : null
// null + string
var r13 = null + d;
>r13 : string
>r13 : string, Symbol(r13, Decl(additionOperatorWithNullValueAndValidOperator.ts, 26, 3))
>null + d : string
>d : string
>null : null
>d : string, Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 3))
var r14 = null + '';
>r14 : string
>r14 : string, Symbol(r14, Decl(additionOperatorWithNullValueAndValidOperator.ts, 27, 3))
>null + '' : string
>null : null
>'' : string
var r15 = d + null;
>r15 : string
>r15 : string, Symbol(r15, Decl(additionOperatorWithNullValueAndValidOperator.ts, 28, 3))
>d + null : string
>d : string
>d : string, Symbol(d, Decl(additionOperatorWithNullValueAndValidOperator.ts, 7, 3))
>null : null
var r16 = '' + null;
>r16 : string
>r16 : string, Symbol(r16, Decl(additionOperatorWithNullValueAndValidOperator.ts, 29, 3))
>'' + null : string
>'' : string
>null : null

122
tests/baselines/reference/additionOperatorWithNumberAndEnum.types
View File

@ -1,115 +1,121 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNumberAndEnum.ts ===
enum E { a, b }
>E : E
>a : E
>b : E
>E : E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithNumberAndEnum.ts, 0, 8))
>b : E, Symbol(E.b, Decl(additionOperatorWithNumberAndEnum.ts, 0, 11))
enum F { c, d }
>F : F
>c : F
>d : F
>F : F, Symbol(F, Decl(additionOperatorWithNumberAndEnum.ts, 0, 15))
>c : F, Symbol(F.c, Decl(additionOperatorWithNumberAndEnum.ts, 1, 8))
>d : F, Symbol(F.d, Decl(additionOperatorWithNumberAndEnum.ts, 1, 11))
var a: number;
>a : number
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
var b: E;
>b : E
>E : E
>b : E, Symbol(b, Decl(additionOperatorWithNumberAndEnum.ts, 4, 3))
>E : E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
var c: E | F;
>c : E | F
>E : E
>F : F
>c : E | F, Symbol(c, Decl(additionOperatorWithNumberAndEnum.ts, 5, 3))
>E : E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>F : F, Symbol(F, Decl(additionOperatorWithNumberAndEnum.ts, 0, 15))
var r1 = a + a;
>r1 : number
>r1 : number, Symbol(r1, Decl(additionOperatorWithNumberAndEnum.ts, 7, 3))
>a + a : number
>a : number
>a : number
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
var r2 = a + b;
>r2 : number
>r2 : number, Symbol(r2, Decl(additionOperatorWithNumberAndEnum.ts, 8, 3))
>a + b : number
>a : number
>b : E
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
>b : E, Symbol(b, Decl(additionOperatorWithNumberAndEnum.ts, 4, 3))
var r3 = b + a;
>r3 : number
>r3 : number, Symbol(r3, Decl(additionOperatorWithNumberAndEnum.ts, 9, 3))
>b + a : number
>b : E
>a : number
>b : E, Symbol(b, Decl(additionOperatorWithNumberAndEnum.ts, 4, 3))
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
var r4 = b + b;
>r4 : number
>r4 : number, Symbol(r4, Decl(additionOperatorWithNumberAndEnum.ts, 10, 3))
>b + b : number
>b : E
>b : E
>b : E, Symbol(b, Decl(additionOperatorWithNumberAndEnum.ts, 4, 3))
>b : E, Symbol(b, Decl(additionOperatorWithNumberAndEnum.ts, 4, 3))
var r5 = 0 + a;
>r5 : number
>r5 : number, Symbol(r5, Decl(additionOperatorWithNumberAndEnum.ts, 12, 3))
>0 + a : number
>a : number
>0 : number
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
var r6 = E.a + 0;
>r6 : number
>r6 : number, Symbol(r6, Decl(additionOperatorWithNumberAndEnum.ts, 13, 3))
>E.a + 0 : number
>E.a : E
>E : typeof E
>a : E
>E.a : E, Symbol(E.a, Decl(additionOperatorWithNumberAndEnum.ts, 0, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithNumberAndEnum.ts, 0, 8))
>0 : number
var r7 = E.a + E.b;
>r7 : number
>r7 : number, Symbol(r7, Decl(additionOperatorWithNumberAndEnum.ts, 14, 3))
>E.a + E.b : number
>E.a : E
>E : typeof E
>a : E
>E.b : E
>E : typeof E
>b : E
>E.a : E, Symbol(E.a, Decl(additionOperatorWithNumberAndEnum.ts, 0, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithNumberAndEnum.ts, 0, 8))
>E.b : E, Symbol(E.b, Decl(additionOperatorWithNumberAndEnum.ts, 0, 11))
>E : typeof E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>b : E, Symbol(E.b, Decl(additionOperatorWithNumberAndEnum.ts, 0, 11))
var r8 = E['a'] + E['b'];
>r8 : number
>r8 : number, Symbol(r8, Decl(additionOperatorWithNumberAndEnum.ts, 15, 3))
>E['a'] + E['b'] : number
>E['a'] : E
>E : typeof E
>E : typeof E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>'a' : string, Symbol(E.a, Decl(additionOperatorWithNumberAndEnum.ts, 0, 8))
>E['b'] : E
>E : typeof E
>E : typeof E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>'b' : string, Symbol(E.b, Decl(additionOperatorWithNumberAndEnum.ts, 0, 11))
var r9 = E['a'] + F['c'];
>r9 : number
>r9 : number, Symbol(r9, Decl(additionOperatorWithNumberAndEnum.ts, 16, 3))
>E['a'] + F['c'] : number
>E['a'] : E
>E : typeof E
>E : typeof E, Symbol(E, Decl(additionOperatorWithNumberAndEnum.ts, 0, 0))
>'a' : string, Symbol(E.a, Decl(additionOperatorWithNumberAndEnum.ts, 0, 8))
>F['c'] : F
>F : typeof F
>F : typeof F, Symbol(F, Decl(additionOperatorWithNumberAndEnum.ts, 0, 15))
>'c' : string, Symbol(F.c, Decl(additionOperatorWithNumberAndEnum.ts, 1, 8))
var r10 = a + c;
>r10 : number
>r10 : number, Symbol(r10, Decl(additionOperatorWithNumberAndEnum.ts, 18, 3))
>a + c : number
>a : number
>c : E | F
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
>c : E | F, Symbol(c, Decl(additionOperatorWithNumberAndEnum.ts, 5, 3))
var r11 = c + a;
>r11 : number
>r11 : number, Symbol(r11, Decl(additionOperatorWithNumberAndEnum.ts, 19, 3))
>c + a : number
>c : E | F
>a : number
>c : E | F, Symbol(c, Decl(additionOperatorWithNumberAndEnum.ts, 5, 3))
>a : number, Symbol(a, Decl(additionOperatorWithNumberAndEnum.ts, 3, 3))
var r12 = b + c;
>r12 : number
>r12 : number, Symbol(r12, Decl(additionOperatorWithNumberAndEnum.ts, 20, 3))
>b + c : number
>b : E
>c : E | F
>b : E, Symbol(b, Decl(additionOperatorWithNumberAndEnum.ts, 4, 3))
>c : E | F, Symbol(c, Decl(additionOperatorWithNumberAndEnum.ts, 5, 3))
var r13 = c + b;
>r13 : number
>r13 : number, Symbol(r13, Decl(additionOperatorWithNumberAndEnum.ts, 21, 3))
>c + b : number
>c : E | F
>b : E
>c : E | F, Symbol(c, Decl(additionOperatorWithNumberAndEnum.ts, 5, 3))
>b : E, Symbol(b, Decl(additionOperatorWithNumberAndEnum.ts, 4, 3))
var r14 = c + c;
>r14 : number
>r14 : number, Symbol(r14, Decl(additionOperatorWithNumberAndEnum.ts, 22, 3))
>c + c : number
>c : E | F
>c : E | F
>c : E | F, Symbol(c, Decl(additionOperatorWithNumberAndEnum.ts, 5, 3))
>c : E | F, Symbol(c, Decl(additionOperatorWithNumberAndEnum.ts, 5, 3))

149
tests/baselines/reference/additionOperatorWithStringAndEveryType.types
View File

@ -1,158 +1,161 @@
=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithStringAndEveryType.ts ===
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
>E : E, Symbol(E, Decl(additionOperatorWithStringAndEveryType.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithStringAndEveryType.ts, 0, 8))
>b : E, Symbol(E.b, Decl(additionOperatorWithStringAndEveryType.ts, 0, 11))
>c : E, Symbol(E.c, Decl(additionOperatorWithStringAndEveryType.ts, 0, 14))
var a: any;
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithStringAndEveryType.ts, 2, 3))
var b: boolean;
>b : boolean
>b : boolean, Symbol(b, Decl(additionOperatorWithStringAndEveryType.ts, 3, 3))
var c: number;
>c : number
>c : number, Symbol(c, Decl(additionOperatorWithStringAndEveryType.ts, 4, 3))
var d: string;
>d : string
>d : string, Symbol(d, Decl(additionOperatorWithStringAndEveryType.ts, 5, 3))
var e: Object;
>e : Object
>Object : Object
>e : Object, Symbol(e, Decl(additionOperatorWithStringAndEveryType.ts, 6, 3))
>Object : Object, Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
var f: void;
>f : void
>f : void, Symbol(f, Decl(additionOperatorWithStringAndEveryType.ts, 7, 3))
var g: E;
>g : E
>E : E
>g : E, Symbol(g, Decl(additionOperatorWithStringAndEveryType.ts, 8, 3))
>E : E, Symbol(E, Decl(additionOperatorWithStringAndEveryType.ts, 0, 0))
var x: string;
>x : string
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
// string could plus every type, and the result is always string
// string as left operand
var r1 = x + a;
>r1 : string
>r1 : string, Symbol(r1, Decl(additionOperatorWithStringAndEveryType.ts, 14, 3))
>x + a : string
>x : string
>a : any
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>a : any, Symbol(a, Decl(additionOperatorWithStringAndEveryType.ts, 2, 3))
var r2 = x + b;
>r2 : string
>r2 : string, Symbol(r2, Decl(additionOperatorWithStringAndEveryType.ts, 15, 3))
>x + b : string
>x : string
>b : boolean
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>b : boolean, Symbol(b, Decl(additionOperatorWithStringAndEveryType.ts, 3, 3))
var r3 = x + c;
>r3 : string
>r3 : string, Symbol(r3, Decl(additionOperatorWithStringAndEveryType.ts, 16, 3))
>x + c : string
>x : string
>c : number
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>c : number, Symbol(c, Decl(additionOperatorWithStringAndEveryType.ts, 4, 3))
var r4 = x + d;
>r4 : string
>r4 : string, Symbol(r4, Decl(additionOperatorWithStringAndEveryType.ts, 17, 3))
>x + d : string
>x : string
>d : string
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>d : string, Symbol(d, Decl(additionOperatorWithStringAndEveryType.ts, 5, 3))
var r5 = x + e;
>r5 : string
>r5 : string, Symbol(r5, Decl(additionOperatorWithStringAndEveryType.ts, 18, 3))
>x + e : string
>x : string
>e : Object
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>e : Object, Symbol(e, Decl(additionOperatorWithStringAndEveryType.ts, 6, 3))
var r6 = x + f;
>r6 : string
>r6 : string, Symbol(r6, Decl(additionOperatorWithStringAndEveryType.ts, 19, 3))
>x + f : string
>x : string
>f : void
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>f : void, Symbol(f, Decl(additionOperatorWithStringAndEveryType.ts, 7, 3))
var r7 = x + g;
>r7 : string
>r7 : string, Symbol(r7, Decl(additionOperatorWithStringAndEveryType.ts, 20, 3))
>x + g : string
>x : string
>g : E
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>g : E, Symbol(g, Decl(additionOperatorWithStringAndEveryType.ts, 8, 3))
// string as right operand
var r8 = a + x;
>r8 : string
>r8 : string, Symbol(r8, Decl(additionOperatorWithStringAndEveryType.ts, 23, 3))
>a + x : string
>a : any
>x : string
>a : any, Symbol(a, Decl(additionOperatorWithStringAndEveryType.ts, 2, 3))
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
var r9 = b + x;
>r9 : string
>r9 : string, Symbol(r9, Decl(additionOperatorWithStringAndEveryType.ts, 24, 3))
>b + x : string
>b : boolean
>x : string
>b : boolean, Symbol(b, Decl(additionOperatorWithStringAndEveryType.ts, 3, 3))
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
var r10 = c + x;
>r10 : string
>r10 : string, Symbol(r10, Decl(additionOperatorWithStringAndEveryType.ts, 25, 3))
>c + x : string
>c : number
>x : string
>c : number, Symbol(c, Decl(additionOperatorWithStringAndEveryType.ts, 4, 3))
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
var r11 = d + x;
>r11 : string
>r11 : string, Symbol(r11, Decl(additionOperatorWithStringAndEveryType.ts, 26, 3))
>d + x : string
>d : string
>x : string
>d : string, Symbol(d, Decl(additionOperatorWithStringAndEveryType.ts, 5, 3))
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
var r12 = e + x;
>r12 : string
>r12 : string, Symbol(r12, Decl(additionOperatorWithStringAndEveryType.ts, 27, 3))
>e + x : string
>e : Object
>x : string
>e : Object, Symbol(e, Decl(additionOperatorWithStringAndEveryType.ts, 6, 3))
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
var r13 = f + x;
>r13 : string
>r13 : string, Symbol(r13, Decl(additionOperatorWithStringAndEveryType.ts, 28, 3))
>f + x : string
>f : void
>x : string
>f : void, Symbol(f, Decl(additionOperatorWithStringAndEveryType.ts, 7, 3))
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
var r14 = g + x;
>r14 : string
>r14 : string, Symbol(r14, Decl(additionOperatorWithStringAndEveryType.ts, 29, 3))
>g + x : string
>g : E
>x : string
>g : E, Symbol(g, Decl(additionOperatorWithStringAndEveryType.ts, 8, 3))
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
// other cases
var r15 = x + E;
>r15 : string
>r15 : string, Symbol(r15, Decl(additionOperatorWithStringAndEveryType.ts, 32, 3))
>x + E : string
>x : string
>E : typeof E
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>E : typeof E, Symbol(E, Decl(additionOperatorWithStringAndEveryType.ts, 0, 0))
var r16 = x + E.a;
>r16 : string
>r16 : string, Symbol(r16, Decl(additionOperatorWithStringAndEveryType.ts, 33, 3))
>x + E.a : string
>x : string
>E.a : E
>E : typeof E
>a : E
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>E.a : E, Symbol(E.a, Decl(additionOperatorWithStringAndEveryType.ts, 0, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithStringAndEveryType.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithStringAndEveryType.ts, 0, 8))
var r17 = x + '';
>r17 : string
>r17 : string, Symbol(r17, Decl(additionOperatorWithStringAndEveryType.ts, 34, 3))
>x + '' : string
>x : string
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>'' : string
var r18 = x + 0;
>r18 : string
>r18 : string, Symbol(r18, Decl(additionOperatorWithStringAndEveryType.ts, 35, 3))
>x + 0 : string
>x : string
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>0 : number
var r19 = x + { a: '' };
>r19 : string
>r19 : string, Symbol(r19, Decl(additionOperatorWithStringAndEveryType.ts, 36, 3))
>x + { a: '' } : string
>x : string
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>{ a: '' } : { a: string; }
>a : string
>a : string, Symbol(a, Decl(additionOperatorWithStringAndEveryType.ts, 36, 15))
>'' : string
var r20 = x + [];
>r20 : string
>r20 : string, Symbol(r20, Decl(additionOperatorWithStringAndEveryType.ts, 37, 3))
>x + [] : string
>x : string
>x : string, Symbol(x, Decl(additionOperatorWithStringAndEveryType.ts, 10, 3))
>[] : undefined[]

120
tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types
View File

@ -2,122 +2,128 @@
// If one operand is the null or undefined value, it is treated as having the type of the other operand.
enum E { a, b, c }
>E : E
>a : E
>b : E
>c : E
>E : E, Symbol(E, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 8))
>b : E, Symbol(E.b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 11))
>c : E, Symbol(E.c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 14))
var a: any;
>a : any
>a : any, Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 3))
var b: number;
>b : number
>b : number, Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 3))
var c: E;
>c : E
>E : E
>c : E, Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 3))
>E : E, Symbol(E, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 0, 0))
var d: string;
>d : string
>d : string, Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 3))
// undefined + any
var r1: any = undefined + a;
>r1 : any
>r1 : any, Symbol(r1, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 10, 3))
>undefined + a : any
>undefined : undefined
>a : any
>undefined : undefined, Symbol(undefined)
>a : any, Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 3))
var r2: any = a + undefined;
>r2 : any
>r2 : any, Symbol(r2, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 11, 3))
>a + undefined : any
>a : any
>undefined : undefined
>a : any, Symbol(a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 4, 3))
>undefined : undefined, Symbol(undefined)
// undefined + number/enum
var r3 = undefined + b;
>r3 : number
>r3 : number, Symbol(r3, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 14, 3))
>undefined + b : number
>undefined : undefined
>b : number
>undefined : undefined, Symbol(undefined)
>b : number, Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 3))
var r4 = undefined + 1;
>r4 : number
>r4 : number, Symbol(r4, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 15, 3))
>undefined + 1 : number
>undefined : undefined
>undefined : undefined, Symbol(undefined)
>1 : number
var r5 = undefined + c;
>r5 : number
>r5 : number, Symbol(r5, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 16, 3))
>undefined + c : number
>undefined : undefined
>c : E
>undefined : undefined, Symbol(undefined)
>c : E, Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 3))
var r6 = undefined + E.a;
>r6 : number
>r6 : number, Symbol(r6, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 17, 3))
>undefined + E.a : number
>undefined : undefined
>E.a : E
>E : typeof E
>a : E
>undefined : undefined, Symbol(undefined)
>E.a : E, Symbol(E.a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 8))
var r7 = undefined + E['a'];
>r7 : number
>r7 : number, Symbol(r7, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 18, 3))
>undefined + E['a'] : number
>undefined : undefined
>undefined : undefined, Symbol(undefined)
>E['a'] : E
>E : typeof E
>E : typeof E, Symbol(E, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 0, 0))
>'a' : string, Symbol(E.a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 8))
var r8 = b + undefined;
>r8 : number
>r8 : number, Symbol(r8, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 19, 3))
>b + undefined : number
>b : number
>undefined : undefined
>b : number, Symbol(b, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 5, 3))
>undefined : undefined, Symbol(undefined)
var r9 = 1 + undefined;
>r9 : number
>r9 : number, Symbol(r9, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 20, 3))
>1 + undefined : number
>undefined : undefined
>1 : number
>undefined : undefined, Symbol(undefined)
var r10 = c + undefined
>r10 : number
>r10 : number, Symbol(r10, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 21, 3))
>c + undefined : number
>c : E
>undefined : undefined
>c : E, Symbol(c, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 6, 3))
>undefined : undefined, Symbol(undefined)
var r11 = E.a + undefined;
>r11 : number
>r11 : number, Symbol(r11, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 22, 3))
>E.a + undefined : number
>E.a : E
>E : typeof E
>a : E
>undefined : undefined
>E.a : E, Symbol(E.a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 8))
>E : typeof E, Symbol(E, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 0, 0))
>a : E, Symbol(E.a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 8))
>undefined : undefined, Symbol(undefined)
var r12 = E['a'] + undefined;
>r12 : number
>r12 : number, Symbol(r12, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 23, 3))
>E['a'] + undefined : number
>E['a'] : E
>E : typeof E
>undefined : undefined
>E : typeof E, Symbol(E, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 0, 0))
>'a' : string, Symbol(E.a, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 2, 8))
>undefined : undefined, Symbol(undefined)
// undefined + string
var r13 = undefined + d;
>r13 : string
>r13 : string, Symbol(r13, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 26, 3))
>undefined + d : string
>undefined : undefined
>d : string
>undefined : undefined, Symbol(undefined)
>d : string, Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 3))
var r14 = undefined + '';
>r14 : string
>r14 : string, Symbol(r14, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 27, 3))
>undefined + '' : string
>undefined : undefined
>undefined : undefined, Symbol(undefined)
>'' : string
var r15 = d + undefined;
>r15 : string
>r15 : string, Symbol(r15, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 28, 3))
>d + undefined : string
>d : string
>undefined : undefined
>d : string, Symbol(d, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 7, 3))
>undefined : undefined, Symbol(undefined)
var r16 = '' + undefined;
>r16 : string
>r16 : string, Symbol(r16, Decl(additionOperatorWithUndefinedValueAndValidOperator.ts, 29, 3))
>'' + undefined : string
>undefined : undefined
>'' : string
>undefined : undefined, Symbol(undefined)

48
tests/baselines/reference/aliasUsageInAccessorsOfClass.types
View File

@ -1,59 +1,61 @@
=== tests/cases/compiler/aliasUsage1_main.ts ===
import Backbone = require("aliasUsage1_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsage1_main.ts, 0, 0))
import moduleA = require("aliasUsage1_moduleA");
>moduleA : typeof moduleA
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsage1_main.ts, 0, 50))
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 48))
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel, Decl(aliasUsage1_main.ts, 2, 34))
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsage1_main.ts, 0, 0))
>Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))
}
class C2 {
>C2 : C2
>C2 : C2, Symbol(C2, Decl(aliasUsage1_main.ts, 4, 1))
x: IHasVisualizationModel;
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>x : IHasVisualizationModel, Symbol(x, Decl(aliasUsage1_main.ts, 5, 10))
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsage1_main.ts, 1, 48))
get A() {
>A : IHasVisualizationModel
>A : IHasVisualizationModel, Symbol(A, Decl(aliasUsage1_main.ts, 6, 30), Decl(aliasUsage1_main.ts, 9, 5))
return this.x;
>this.x : IHasVisualizationModel
>this : C2
>x : IHasVisualizationModel
>this.x : IHasVisualizationModel, Symbol(x, Decl(aliasUsage1_main.ts, 5, 10))
>this : C2, Symbol(C2, Decl(aliasUsage1_main.ts, 4, 1))
>x : IHasVisualizationModel, Symbol(x, Decl(aliasUsage1_main.ts, 5, 10))
}
set A(x) {
>A : IHasVisualizationModel
>x : IHasVisualizationModel
>A : IHasVisualizationModel, Symbol(A, Decl(aliasUsage1_main.ts, 6, 30), Decl(aliasUsage1_main.ts, 9, 5))
>x : IHasVisualizationModel, Symbol(x, Decl(aliasUsage1_main.ts, 10, 10))
x = moduleA;
>x = moduleA : typeof moduleA
>x : IHasVisualizationModel
>moduleA : typeof moduleA
>x : IHasVisualizationModel, Symbol(x, Decl(aliasUsage1_main.ts, 10, 10))
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsage1_main.ts, 0, 50))
}
}
=== tests/cases/compiler/aliasUsage1_backbone.ts ===
export class Model {
>Model : Model
>Model : Model, Symbol(Model, Decl(aliasUsage1_backbone.ts, 0, 0))
public someData: string;
>someData : string
>someData : string, Symbol(someData, Decl(aliasUsage1_backbone.ts, 0, 20))
}
=== tests/cases/compiler/aliasUsage1_moduleA.ts ===
import Backbone = require("aliasUsage1_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsage1_moduleA.ts, 0, 0))
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : typeof Backbone
>Model : Backbone.Model
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel, Decl(aliasUsage1_moduleA.ts, 0, 50))
>Backbone.Model : any, Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsage1_moduleA.ts, 0, 0))
>Model : Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsage1_backbone.ts, 0, 0))
// interesting stuff here
}

38
tests/baselines/reference/aliasUsageInArray.types
View File

@ -1,47 +1,49 @@
=== tests/cases/compiler/aliasUsageInArray_main.ts ===
import Backbone = require("aliasUsageInArray_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInArray_main.ts, 0, 0))
import moduleA = require("aliasUsageInArray_moduleA");
>moduleA : typeof moduleA
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsageInArray_main.ts, 1, 54))
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel, Decl(aliasUsageInArray_main.ts, 2, 34))
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInArray_main.ts, 0, 0))
>Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
}
var xs: IHasVisualizationModel[] = [moduleA];
>xs : IHasVisualizationModel[]
>IHasVisualizationModel : IHasVisualizationModel
>xs : IHasVisualizationModel[], Symbol(xs, Decl(aliasUsageInArray_main.ts, 6, 3))
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsageInArray_main.ts, 1, 54))
>[moduleA] : typeof moduleA[]
>moduleA : typeof moduleA
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
var xs2: typeof moduleA[] = [moduleA];
>xs2 : typeof moduleA[]
>moduleA : typeof moduleA
>xs2 : typeof moduleA[], Symbol(xs2, Decl(aliasUsageInArray_main.ts, 7, 3))
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
>[moduleA] : typeof moduleA[]
>moduleA : typeof moduleA
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInArray_main.ts, 0, 56))
=== tests/cases/compiler/aliasUsageInArray_backbone.ts ===
export class Model {
>Model : Model
>Model : Model, Symbol(Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
public someData: string;
>someData : string
>someData : string, Symbol(someData, Decl(aliasUsageInArray_backbone.ts, 0, 20))
}
=== tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
import Backbone = require("aliasUsageInArray_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInArray_moduleA.ts, 0, 0))
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : typeof Backbone
>Model : Backbone.Model
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel, Decl(aliasUsageInArray_moduleA.ts, 0, 56))
>Backbone.Model : any, Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInArray_moduleA.ts, 0, 0))
>Model : Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInArray_backbone.ts, 0, 0))
// interesting stuff here
}

40
tests/baselines/reference/aliasUsageInFunctionExpression.types
View File

@ -1,48 +1,50 @@
=== tests/cases/compiler/aliasUsageInFunctionExpression_main.ts ===
import Backbone = require("aliasUsageInFunctionExpression_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInFunctionExpression_main.ts, 0, 0))
import moduleA = require("aliasUsageInFunctionExpression_moduleA");
>moduleA : typeof moduleA
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 69))
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 67))
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 2, 34))
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInFunctionExpression_main.ts, 0, 0))
>Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
}
var f = (x: IHasVisualizationModel) => x;
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
>f : (x: IHasVisualizationModel) => IHasVisualizationModel, Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
>(x: IHasVisualizationModel) => x : (x: IHasVisualizationModel) => IHasVisualizationModel
>x : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>x : IHasVisualizationModel
>x : IHasVisualizationModel, Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsageInFunctionExpression_main.ts, 1, 67))
>x : IHasVisualizationModel, Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 5, 9))
f = (x) => moduleA;
>f = (x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
>f : (x: IHasVisualizationModel) => IHasVisualizationModel, Symbol(f, Decl(aliasUsageInFunctionExpression_main.ts, 5, 3))
>(x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
>x : IHasVisualizationModel
>moduleA : typeof moduleA
>x : IHasVisualizationModel, Symbol(x, Decl(aliasUsageInFunctionExpression_main.ts, 6, 5))
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInFunctionExpression_main.ts, 0, 69))
=== tests/cases/compiler/aliasUsageInFunctionExpression_backbone.ts ===
export class Model {
>Model : Model
>Model : Model, Symbol(Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
public someData: string;
>someData : string
>someData : string, Symbol(someData, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 20))
}
=== tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
import Backbone = require("aliasUsageInFunctionExpression_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInFunctionExpression_moduleA.ts, 0, 0))
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : typeof Backbone
>Model : Backbone.Model
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel, Decl(aliasUsageInFunctionExpression_moduleA.ts, 0, 69))
>Backbone.Model : any, Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInFunctionExpression_moduleA.ts, 0, 0))
>Model : Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInFunctionExpression_backbone.ts, 0, 0))
// interesting stuff here
}

57
tests/baselines/reference/aliasUsageInGenericFunction.types
View File

@ -1,62 +1,65 @@
=== tests/cases/compiler/aliasUsageInGenericFunction_main.ts ===
import Backbone = require("aliasUsageInGenericFunction_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInGenericFunction_main.ts, 0, 0))
import moduleA = require("aliasUsageInGenericFunction_moduleA");
>moduleA : typeof moduleA
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 66))
interface IHasVisualizationModel {
>IHasVisualizationModel : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
VisualizationModel: typeof Backbone.Model;
>VisualizationModel : typeof Backbone.Model
>Backbone : typeof Backbone
>Model : typeof Backbone.Model
>VisualizationModel : typeof Backbone.Model, Symbol(VisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 2, 34))
>Backbone.Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInGenericFunction_main.ts, 0, 0))
>Model : typeof Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
}
function foo<T extends { a: IHasVisualizationModel }>(x: T) {
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
>T : T
>a : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>x : T
>T : T
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T, Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
>T : T, Symbol(T, Decl(aliasUsageInGenericFunction_main.ts, 5, 13))
>a : IHasVisualizationModel, Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 5, 24))
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
>x : T, Symbol(x, Decl(aliasUsageInGenericFunction_main.ts, 5, 54))
>T : T, Symbol(T, Decl(aliasUsageInGenericFunction_main.ts, 5, 13))
return x;
>x : T
>x : T, Symbol(x, Decl(aliasUsageInGenericFunction_main.ts, 5, 54))
}
var r = foo({ a: moduleA });
>r : { a: typeof moduleA; }
>r : { a: typeof moduleA; }, Symbol(r, Decl(aliasUsageInGenericFunction_main.ts, 8, 3))
>foo({ a: moduleA }) : { a: typeof moduleA; }
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T, Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
>{ a: moduleA } : { a: typeof moduleA; }
>a : typeof moduleA
>moduleA : typeof moduleA
>a : typeof moduleA, Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 8, 13))
>moduleA : typeof moduleA, Symbol(moduleA, Decl(aliasUsageInGenericFunction_main.ts, 0, 66))
var r2 = foo({ a: <IHasVisualizationModel>null });
>r2 : { a: IHasVisualizationModel; }
>r2 : { a: IHasVisualizationModel; }, Symbol(r2, Decl(aliasUsageInGenericFunction_main.ts, 9, 3))
>foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T, Symbol(foo, Decl(aliasUsageInGenericFunction_main.ts, 4, 1))
>{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
>a : IHasVisualizationModel
>a : IHasVisualizationModel, Symbol(a, Decl(aliasUsageInGenericFunction_main.ts, 9, 14))
><IHasVisualizationModel>null : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel
>IHasVisualizationModel : IHasVisualizationModel, Symbol(IHasVisualizationModel, Decl(aliasUsageInGenericFunction_main.ts, 1, 64))
>null : null
=== tests/cases/compiler/aliasUsageInGenericFunction_backbone.ts ===
export class Model {
>Model : Model
>Model : Model, Symbol(Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
public someData: string;
>someData : string
>someData : string, Symbol(someData, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 20))
}
=== tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
import Backbone = require("aliasUsageInGenericFunction_backbone");
>Backbone : typeof Backbone
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInGenericFunction_moduleA.ts, 0, 0))
export class VisualizationModel extends Backbone.Model {
>VisualizationModel : VisualizationModel
>Backbone : typeof Backbone
>Model : Backbone.Model
>VisualizationModel : VisualizationModel, Symbol(VisualizationModel, Decl(aliasUsageInGenericFunction_moduleA.ts, 0, 66))
>Backbone.Model : any, Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
>Backbone : typeof Backbone, Symbol(Backbone, Decl(aliasUsageInGenericFunction_moduleA.ts, 0, 0))
>Model : Backbone.Model, Symbol(Backbone.Model, Decl(aliasUsageInGenericFunction_backbone.ts, 0, 0))
// interesting stuff here
}

Some files were not shown because too many files have changed in this diff Show More