Merge pull request #2783 from Microsoft/symbolWriter2

Split symbol baselines from type baselines.

src/harness/compilerRunner.ts

@@ -270,29 +270,53 @@ class CompilerBaselineRunner extends RunnerBase {
                     // These types are equivalent, but depend on what order the compiler observed 
                     // certain parts of the program.
 
-                    var fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
-                    var pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
+                    let allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
 
-                    var fullTypes = generateTypes(fullWalker);
-                    var pullTypes = generateTypes(pullWalker);
+                    let fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
+                    let pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
 
-                    if (fullTypes !== pullTypes) {
-                        Harness.Baseline.runBaseline('Correct full expression types for ' + fileName, justName.replace(/\.ts/, '.types'), () => fullTypes);
-                        Harness.Baseline.runBaseline('Correct pull expression types for ' + fileName, justName.replace(/\.ts/, '.types.pull'), () => pullTypes);
-                    }
-                    else {
-                        Harness.Baseline.runBaseline('Correct expression types for ' + fileName, justName.replace(/\.ts/, '.types'), () => fullTypes);
+                    let fullResults: ts.Map<TypeWriterResult[]> = {};
+                    let pullResults: ts.Map<TypeWriterResult[]> = {};
+
+                    for (let sourceFile of allFiles) {
+                        fullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
+                        pullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
                     }
 
-                    function generateTypes(walker: TypeWriterWalker): string {
-                        var allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
-                        var typeLines: string[] = [];
-                        var typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
+                    // Produce baselines.  The first gives the types for all expressions.
+                    // The second gives symbols for all identifiers.
+                    checkBaseLines(/*isSymbolBaseLine:*/ false);
+                    checkBaseLines(/*isSymbolBaseLine:*/ true);
+
+                    function checkBaseLines(isSymbolBaseLine: boolean) {
+                        let fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
+                        let pullBaseLine = generateBaseLine(pullResults, isSymbolBaseLine);
+
+                        let fullExtension = isSymbolBaseLine ? '.symbols' : '.types';
+                        let pullExtension = isSymbolBaseLine ? '.symbols.pull' : '.types.pull';
+
+                        if (fullBaseLine !== pullBaseLine) {
+                            Harness.Baseline.runBaseline('Correct full information for ' + fileName, justName.replace(/\.ts/, fullExtension), () => fullBaseLine);
+                            Harness.Baseline.runBaseline('Correct pull information for ' + fileName, justName.replace(/\.ts/, pullExtension), () => pullBaseLine);
+                        }
+                        else {
+                            Harness.Baseline.runBaseline('Correct information for ' + fileName, justName.replace(/\.ts/, fullExtension), () => fullBaseLine);
+                        }
+                    }
+
+                    function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {
+                        let typeLines: string[] = [];
+                        let typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
 
                         allFiles.forEach(file => {
                             var codeLines = file.content.split('\n');
-                            walker.getTypes(file.unitName).forEach(result => {
-                                var formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + result.type;
+                            typeWriterResults[file.unitName].forEach(result => {
+                                if (isSymbolBaseline && !result.symbol) {
+                                    return;
+                                }
+
+                                var typeOrSymbolString = isSymbolBaseline ? result.symbol : result.type;
+                                var formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + typeOrSymbolString;
                                 if (!typeMap[file.unitName]) {
                                     typeMap[file.unitName] = {};
                                 }
@@ -316,11 +340,13 @@ class CompilerBaselineRunner extends RunnerBase {
                                             typeLines.push('>' + ty + '\r\n');
                                         });
                                         if (i + 1 < codeLines.length && (codeLines[i + 1].match(/^\s*[{|}]\s*$/) || codeLines[i + 1].trim() === '')) {
-                                        } else {
+                                        }
+                                        else {
                                             typeLines.push('\r\n');
                                         }
                                     }
-                                } else {
+                                }
+                                else {
                                     typeLines.push('No type information for this code.');
                                 }
                             }

src/harness/typeWriter.ts

@@ -3,6 +3,7 @@ interface TypeWriterResult {
     syntaxKind: number;
     sourceText: string;
     type: string;
+    symbol: string;
 }
 
 class TypeWriterWalker {
@@ -19,7 +20,7 @@ class TypeWriterWalker {
             : program.getTypeChecker();
     }
 
-    public getTypes(fileName: string): TypeWriterResult[] {
+    public getTypeAndSymbols(fileName: string): TypeWriterResult[] {
         var sourceFile = this.program.getSourceFile(fileName);
         this.currentSourceFile = sourceFile;
         this.results = [];
@@ -45,8 +46,9 @@ class TypeWriterWalker {
         var symbol = this.checker.getSymbolAtLocation(node);
 
         var typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
+        var symbolString: string;
         if (symbol) {
-            var symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
+            symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
             if (symbol.declarations) {
                 for (let declaration of symbol.declarations) {
                     symbolString += ", ";
@@ -56,15 +58,14 @@ class TypeWriterWalker {
                 }
             }
             symbolString += ")";
-
-            typeString += ", " + symbolString;
         }
 
         this.results.push({
             line: lineAndCharacter.line,
             syntaxKind: node.kind,
             sourceText: sourceText,
-            type: typeString
+            type: typeString,
+            symbol: symbolString
         });
     }
 }

tests/baselines/reference/2dArrays.symbols

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

tests/baselines/reference/2dArrays.types

@@ -1,40 +1,40 @@
 === tests/cases/compiler/2dArrays.ts ===
 class Cell {
->Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
+>Cell : Cell
 }
 
 class Ship {
->Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
+>Ship : Ship
 
     isSunk: boolean;
->isSunk : boolean, Symbol(isSunk, Decl(2dArrays.ts, 3, 12))
+>isSunk : boolean
 }
 
 class Board {
->Board : Board, Symbol(Board, Decl(2dArrays.ts, 5, 1))
+>Board : Board
 
     ships: Ship[];
->ships : Ship[], Symbol(ships, Decl(2dArrays.ts, 7, 13))
->Ship : Ship, Symbol(Ship, Decl(2dArrays.ts, 1, 1))
+>ships : Ship[]
+>Ship : Ship
 
     cells: Cell[];
->cells : Cell[], Symbol(cells, Decl(2dArrays.ts, 8, 18))
->Cell : Cell, Symbol(Cell, Decl(2dArrays.ts, 0, 0))
+>cells : Cell[]
+>Cell : Cell
 
     private allShipsSunk() {
->allShipsSunk : () => boolean, Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18))
+>allShipsSunk : () => boolean
 
         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, 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))
+>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
 >function (val) { return val.isSunk; } : (val: Ship) => 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))
+>val : Ship
+>val.isSunk : boolean
+>val : Ship
+>isSunk : boolean
     }    
 }

tests/baselines/reference/APISample_compile.symbols

@@ -0,0 +1,131 @@
+=== tests/cases/compiler/APISample_compile.ts ===
+
+/*
+ * Note: This test is a public API sample. The sample sources can be found 
+         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-minimal-compiler
+ *       Please log a "breaking change" issue for any API breaking change affecting this issue
+ */
+
+declare var process: any;
+>process : Symbol(process, Decl(APISample_compile.ts, 7, 11))
+
+declare var console: any;
+>console : Symbol(console, Decl(APISample_compile.ts, 8, 11))
+
+declare var os: any;
+>os : Symbol(os, Decl(APISample_compile.ts, 9, 11))
+
+import ts = require("typescript");
+>ts : Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+
+export function compile(fileNames: string[], options: ts.CompilerOptions): void {
+>compile : Symbol(compile, Decl(APISample_compile.ts, 11, 34))
+>fileNames : Symbol(fileNames, Decl(APISample_compile.ts, 13, 24))
+>options : Symbol(options, Decl(APISample_compile.ts, 13, 44))
+>ts : Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+>CompilerOptions : Symbol(ts.CompilerOptions, Decl(typescript.d.ts, 1074, 5))
+
+    var program = ts.createProgram(fileNames, options);
+>program : Symbol(program, Decl(APISample_compile.ts, 14, 7))
+>ts.createProgram : Symbol(ts.createProgram, Decl(typescript.d.ts, 1225, 113))
+>ts : Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+>createProgram : Symbol(ts.createProgram, Decl(typescript.d.ts, 1225, 113))
+>fileNames : Symbol(fileNames, Decl(APISample_compile.ts, 13, 24))
+>options : Symbol(options, Decl(APISample_compile.ts, 13, 44))
+
+    var emitResult = program.emit();
+>emitResult : Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
+>program.emit : Symbol(ts.Program.emit, Decl(typescript.d.ts, 767, 39))
+>program : Symbol(program, Decl(APISample_compile.ts, 14, 7))
+>emit : Symbol(ts.Program.emit, Decl(typescript.d.ts, 767, 39))
+
+    var allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+>allDiagnostics : Symbol(allDiagnostics, Decl(APISample_compile.ts, 17, 7))
+>ts.getPreEmitDiagnostics(program).concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>ts.getPreEmitDiagnostics : Symbol(ts.getPreEmitDiagnostics, Decl(typescript.d.ts, 1223, 98))
+>ts : Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+>getPreEmitDiagnostics : Symbol(ts.getPreEmitDiagnostics, Decl(typescript.d.ts, 1223, 98))
+>program : Symbol(program, Decl(APISample_compile.ts, 14, 7))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>emitResult.diagnostics : Symbol(ts.EmitResult.diagnostics, Decl(typescript.d.ts, 820, 29))
+>emitResult : Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
+>diagnostics : Symbol(ts.EmitResult.diagnostics, Decl(typescript.d.ts, 820, 29))
+
+    allDiagnostics.forEach(diagnostic => {
+>allDiagnostics.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>allDiagnostics : Symbol(allDiagnostics, Decl(APISample_compile.ts, 17, 7))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>diagnostic : Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
+
+        var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+>line : Symbol(line, Decl(APISample_compile.ts, 20, 13))
+>character : Symbol(character, Decl(APISample_compile.ts, 20, 19))
+>diagnostic.file.getLineAndCharacterOfPosition : Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
+>diagnostic.file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>diagnostic : Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
+>file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>getLineAndCharacterOfPosition : Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
+>diagnostic.start : Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
+>diagnostic : Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
+>start : Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
+
+        var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+>message : Symbol(message, Decl(APISample_compile.ts, 21, 11))
+>ts.flattenDiagnosticMessageText : Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1224, 67))
+>ts : Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+>flattenDiagnosticMessageText : Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1224, 67))
+>diagnostic.messageText : Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
+>diagnostic : Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
+>messageText : Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
+
+        console.log(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+>console : Symbol(console, Decl(APISample_compile.ts, 8, 11))
+>diagnostic.file.fileName : Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
+>diagnostic.file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>diagnostic : Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
+>file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>fileName : Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
+>line : Symbol(line, Decl(APISample_compile.ts, 20, 13))
+>character : Symbol(character, Decl(APISample_compile.ts, 20, 19))
+>message : Symbol(message, Decl(APISample_compile.ts, 21, 11))
+
+    });
+
+    var exitCode = emitResult.emitSkipped ? 1 : 0;
+>exitCode : Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
+>emitResult.emitSkipped : Symbol(ts.EmitResult.emitSkipped, Decl(typescript.d.ts, 819, 26))
+>emitResult : Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
+>emitSkipped : Symbol(ts.EmitResult.emitSkipped, Decl(typescript.d.ts, 819, 26))
+
+    console.log(`Process exiting with code '${exitCode}'.`);
+>console : Symbol(console, Decl(APISample_compile.ts, 8, 11))
+>exitCode : Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
+
+    process.exit(exitCode);
+>process : Symbol(process, Decl(APISample_compile.ts, 7, 11))
+>exitCode : Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
+}
+
+compile(process.argv.slice(2), {
+>compile : Symbol(compile, Decl(APISample_compile.ts, 11, 34))
+>process : Symbol(process, Decl(APISample_compile.ts, 7, 11))
+
+    noEmitOnError: true, noImplicitAny: true,
+>noEmitOnError : Symbol(noEmitOnError, Decl(APISample_compile.ts, 30, 32))
+>noImplicitAny : Symbol(noImplicitAny, Decl(APISample_compile.ts, 31, 24))
+
+    target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS
+>target : Symbol(target, Decl(APISample_compile.ts, 31, 45))
+>ts.ScriptTarget.ES5 : Symbol(ts.ScriptTarget.ES5, Decl(typescript.d.ts, 1117, 16))
+>ts.ScriptTarget : Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
+>ts : Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+>ScriptTarget : Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
+>ES5 : Symbol(ts.ScriptTarget.ES5, Decl(typescript.d.ts, 1117, 16))
+>module : Symbol(module, Decl(APISample_compile.ts, 32, 32))
+>ts.ModuleKind.CommonJS : Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
+>ts.ModuleKind : Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
+>ts : Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+>ModuleKind : Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
+>CommonJS : Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
+
+});

tests/baselines/reference/APISample_compile.types

@@ -7,162 +7,162 @@
  */
 
 declare var process: any;
->process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
+>process : any
 
 declare var console: any;
->console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
+>console : any
 
 declare var os: any;
->os : any, Symbol(os, Decl(APISample_compile.ts, 9, 11))
+>os : any
 
 import ts = require("typescript");
->ts : typeof ts, Symbol(ts, Decl(APISample_compile.ts, 9, 20))
+>ts : typeof ts
 
 export function compile(fileNames: string[], options: ts.CompilerOptions): void {
->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))
+>compile : (fileNames: string[], options: ts.CompilerOptions) => void
+>fileNames : string[]
+>options : ts.CompilerOptions
+>ts : any
+>CompilerOptions : ts.CompilerOptions
 
     var program = ts.createProgram(fileNames, options);
->program : ts.Program, Symbol(program, Decl(APISample_compile.ts, 14, 7))
+>program : ts.Program
 >ts.createProgram(fileNames, options) : ts.Program
->ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host?: ts.CompilerHost) => ts.Program, Symbol(ts.createProgram, Decl(typescript.d.ts, 1225, 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, 1225, 113))
->fileNames : string[], Symbol(fileNames, Decl(APISample_compile.ts, 13, 24))
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_compile.ts, 13, 44))
+>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
 
     var emitResult = program.emit();
->emitResult : ts.EmitResult, Symbol(emitResult, Decl(APISample_compile.ts, 15, 7))
+>emitResult : ts.EmitResult
 >program.emit() : 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))
+>program.emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
+>program : ts.Program
+>emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
 
     var allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
->allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_compile.ts, 17, 7))
+>allDiagnostics : ts.Diagnostic[]
 >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[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>ts.getPreEmitDiagnostics(program).concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
 >ts.getPreEmitDiagnostics(program) : ts.Diagnostic[]
->ts.getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[], Symbol(ts.getPreEmitDiagnostics, Decl(typescript.d.ts, 1223, 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, 1223, 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))
+>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[]
 
     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, 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))
+>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
 >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, Symbol(diagnostic, Decl(APISample_compile.ts, 19, 27))
+>diagnostic : ts.Diagnostic
 
         var { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
->line : number, Symbol(line, Decl(APISample_compile.ts, 20, 13))
->character : number, Symbol(character, Decl(APISample_compile.ts, 20, 19))
+>line : number
+>character : number
 >diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
->diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
->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, 1286, 26))
->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))
+>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
 
         var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
->message : string, Symbol(message, Decl(APISample_compile.ts, 21, 11))
+>message : string
 >ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n') : string
->ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1224, 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, 1224, 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))
+>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
 >'\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, Symbol(console, Decl(APISample_compile.ts, 8, 11))
+>console : any
 >log : any
 >`${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))
+>diagnostic.file.fileName : string
+>diagnostic.file : ts.SourceFile
+>diagnostic : ts.Diagnostic
+>file : ts.SourceFile
+>fileName : string
 >line + 1 : number
->line : number, Symbol(line, Decl(APISample_compile.ts, 20, 13))
+>line : number
 >1 : number
 >character + 1 : number
->character : number, Symbol(character, Decl(APISample_compile.ts, 20, 19))
+>character : number
 >1 : number
->message : string, Symbol(message, Decl(APISample_compile.ts, 21, 11))
+>message : string
 
     });
 
     var exitCode = emitResult.emitSkipped ? 1 : 0;
->exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
+>exitCode : number
 >emitResult.emitSkipped ? 1 : 0 : number
->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))
+>emitResult.emitSkipped : boolean
+>emitResult : ts.EmitResult
+>emitSkipped : boolean
 >1 : number
 >0 : number
 
     console.log(`Process exiting with code '${exitCode}'.`);
 >console.log(`Process exiting with code '${exitCode}'.`) : any
 >console.log : any
->console : any, Symbol(console, Decl(APISample_compile.ts, 8, 11))
+>console : any
 >log : any
 >`Process exiting with code '${exitCode}'.` : string
->exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
+>exitCode : number
 
     process.exit(exitCode);
 >process.exit(exitCode) : any
 >process.exit : any
->process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
+>process : any
 >exit : any
->exitCode : number, Symbol(exitCode, Decl(APISample_compile.ts, 25, 7))
+>exitCode : number
 }
 
 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, Symbol(compile, Decl(APISample_compile.ts, 11, 34))
+>compile : (fileNames: string[], options: ts.CompilerOptions) => void
 >process.argv.slice(2) : any
 >process.argv.slice : any
 >process.argv : any
->process : any, Symbol(process, Decl(APISample_compile.ts, 7, 11))
+>process : any
 >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, Symbol(noEmitOnError, Decl(APISample_compile.ts, 30, 32))
+>noEmitOnError : boolean
 >true : boolean
->noImplicitAny : boolean, Symbol(noImplicitAny, Decl(APISample_compile.ts, 31, 24))
+>noImplicitAny : boolean
 >true : boolean
 
     target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS
->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))
+>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
 
 });

tests/baselines/reference/APISample_linter.symbols

@@ -0,0 +1,260 @@
+=== tests/cases/compiler/APISample_linter.ts ===
+
+/*
+ * Note: This test is a public API sample. The sample sources can be found 
+         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter
+ *       Please log a "breaking change" issue for any API breaking change affecting this issue
+ */
+
+declare var process: any;
+>process : Symbol(process, Decl(APISample_linter.ts, 7, 11))
+
+declare var console: any;
+>console : Symbol(console, Decl(APISample_linter.ts, 8, 11))
+
+declare var readFileSync: any;
+>readFileSync : Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
+
+import * as ts from "typescript";
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+
+export function delint(sourceFile: ts.SourceFile) {
+>delint : Symbol(delint, Decl(APISample_linter.ts, 11, 33))
+>sourceFile : Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SourceFile : Symbol(ts.SourceFile, Decl(typescript.d.ts, 740, 5), Decl(typescript.d.ts, 1285, 5))
+
+    delintNode(sourceFile);
+>delintNode : Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
+>sourceFile : Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
+
+    function delintNode(node: ts.Node) {
+>delintNode : Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>Node : Symbol(ts.Node, Decl(typescript.d.ts, 296, 5), Decl(typescript.d.ts, 1245, 32))
+
+        switch (node.kind) {
+>node.kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+>kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+
+            case ts.SyntaxKind.ForStatement:
+>ts.SyntaxKind.ForStatement : Symbol(ts.SyntaxKind.ForStatement, Decl(typescript.d.ts, 209, 29))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ForStatement : Symbol(ts.SyntaxKind.ForStatement, Decl(typescript.d.ts, 209, 29))
+
+            case ts.SyntaxKind.ForInStatement:
+>ts.SyntaxKind.ForInStatement : Symbol(ts.SyntaxKind.ForInStatement, Decl(typescript.d.ts, 210, 27))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ForInStatement : Symbol(ts.SyntaxKind.ForInStatement, Decl(typescript.d.ts, 210, 27))
+
+            case ts.SyntaxKind.WhileStatement:
+>ts.SyntaxKind.WhileStatement : Symbol(ts.SyntaxKind.WhileStatement, Decl(typescript.d.ts, 208, 26))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>WhileStatement : Symbol(ts.SyntaxKind.WhileStatement, Decl(typescript.d.ts, 208, 26))
+
+            case ts.SyntaxKind.DoStatement:
+>ts.SyntaxKind.DoStatement : Symbol(ts.SyntaxKind.DoStatement, Decl(typescript.d.ts, 207, 26))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>DoStatement : Symbol(ts.SyntaxKind.DoStatement, Decl(typescript.d.ts, 207, 26))
+
+                if ((<ts.IterationStatement>node).statement.kind !== ts.SyntaxKind.Block) {
+>(<ts.IterationStatement>node).statement.kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>(<ts.IterationStatement>node).statement : Symbol(ts.IterationStatement.statement, Decl(typescript.d.ts, 589, 52))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>IterationStatement : Symbol(ts.IterationStatement, Decl(typescript.d.ts, 588, 5))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+>statement : Symbol(ts.IterationStatement.statement, Decl(typescript.d.ts, 589, 52))
+>kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>ts.SyntaxKind.Block : Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>Block : 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 : Symbol(report, Decl(APISample_linter.ts, 48, 5))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+                }
+                break;
+
+            case ts.SyntaxKind.IfStatement:
+>ts.SyntaxKind.IfStatement : Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>IfStatement : Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
+
+                let ifStatement = (<ts.IfStatement>node);
+>ifStatement : Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>IfStatement : Symbol(ts.IfStatement, Decl(typescript.d.ts, 583, 5))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+
+                if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) {
+>ifStatement.thenStatement.kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>ifStatement.thenStatement : Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
+>ifStatement : Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>thenStatement : Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
+>kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>ts.SyntaxKind.Block : Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>Block : 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 : Symbol(report, Decl(APISample_linter.ts, 48, 5))
+>ifStatement.thenStatement : Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
+>ifStatement : Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>thenStatement : Symbol(ts.IfStatement.thenStatement, Decl(typescript.d.ts, 585, 31))
+                }
+                if (ifStatement.elseStatement &&
+>ifStatement.elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+>ifStatement : Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+
+                    ifStatement.elseStatement.kind !== ts.SyntaxKind.Block &&
+>ifStatement.elseStatement.kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>ifStatement.elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+>ifStatement : Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+>kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>ts.SyntaxKind.Block : Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>Block : Symbol(ts.SyntaxKind.Block, Decl(typescript.d.ts, 202, 36))
+
+                    ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) {
+>ifStatement.elseStatement.kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>ifStatement.elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+>ifStatement : Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+>kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>ts.SyntaxKind.IfStatement : Symbol(ts.SyntaxKind.IfStatement, Decl(typescript.d.ts, 206, 34))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>IfStatement : 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 : Symbol(report, Decl(APISample_linter.ts, 48, 5))
+>ifStatement.elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+>ifStatement : Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>elseStatement : Symbol(ts.IfStatement.elseStatement, Decl(typescript.d.ts, 586, 33))
+                }
+                break;
+
+            case ts.SyntaxKind.BinaryExpression:
+>ts.SyntaxKind.BinaryExpression : Symbol(ts.SyntaxKind.BinaryExpression, Decl(typescript.d.ts, 192, 37))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>BinaryExpression : Symbol(ts.SyntaxKind.BinaryExpression, Decl(typescript.d.ts, 192, 37))
+
+                let op = (<ts.BinaryExpression>node).operatorToken.kind;
+>op : Symbol(op, Decl(APISample_linter.ts, 40, 19))
+>(<ts.BinaryExpression>node).operatorToken.kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+>(<ts.BinaryExpression>node).operatorToken : Symbol(ts.BinaryExpression.operatorToken, Decl(typescript.d.ts, 497, 25))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>BinaryExpression : Symbol(ts.BinaryExpression, Decl(typescript.d.ts, 495, 5))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+>operatorToken : Symbol(ts.BinaryExpression.operatorToken, Decl(typescript.d.ts, 497, 25))
+>kind : Symbol(ts.Node.kind, Decl(typescript.d.ts, 297, 38))
+
+                if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) {
+>op : Symbol(op, Decl(APISample_linter.ts, 40, 19))
+>ts.SyntaxKind.EqualsEqualsToken : Symbol(ts.SyntaxKind.EqualsEqualsToken, Decl(typescript.d.ts, 51, 36))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>EqualsEqualsToken : Symbol(ts.SyntaxKind.EqualsEqualsToken, Decl(typescript.d.ts, 51, 36))
+>op : Symbol(op, Decl(APISample_linter.ts, 40, 19))
+>ts.SyntaxKind.ExclamationEqualsToken : Symbol(ts.SyntaxKind.ExclamationEqualsToken, Decl(typescript.d.ts, 52, 31))
+>ts.SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>SyntaxKind : Symbol(ts.SyntaxKind, Decl(typescript.d.ts, 22, 5))
+>ExclamationEqualsToken : Symbol(ts.SyntaxKind.ExclamationEqualsToken, Decl(typescript.d.ts, 52, 31))
+
+                    report(node, "Use '===' and '!=='.")
+>report : Symbol(report, Decl(APISample_linter.ts, 48, 5))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+                }
+                break;
+        }
+
+        ts.forEachChild(node, delintNode);
+>ts.forEachChild : Symbol(ts.forEachChild, Decl(typescript.d.ts, 1214, 48))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>forEachChild : Symbol(ts.forEachChild, Decl(typescript.d.ts, 1214, 48))
+>node : Symbol(node, Decl(APISample_linter.ts, 16, 24))
+>delintNode : Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
+    }
+
+    function report(node: ts.Node, message: string) {
+>report : Symbol(report, Decl(APISample_linter.ts, 48, 5))
+>node : Symbol(node, Decl(APISample_linter.ts, 50, 20))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>Node : Symbol(ts.Node, Decl(typescript.d.ts, 296, 5), Decl(typescript.d.ts, 1245, 32))
+>message : Symbol(message, Decl(APISample_linter.ts, 50, 34))
+
+        let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+>line : Symbol(line, Decl(APISample_linter.ts, 51, 13))
+>character : Symbol(character, Decl(APISample_linter.ts, 51, 19))
+>sourceFile.getLineAndCharacterOfPosition : Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
+>sourceFile : Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
+>getLineAndCharacterOfPosition : Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
+>node.getStart : Symbol(ts.Node.getStart, Decl(typescript.d.ts, 1250, 53))
+>node : Symbol(node, Decl(APISample_linter.ts, 50, 20))
+>getStart : Symbol(ts.Node.getStart, Decl(typescript.d.ts, 1250, 53))
+
+        console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`);
+>console : Symbol(console, Decl(APISample_linter.ts, 8, 11))
+>sourceFile.fileName : Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
+>sourceFile : Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
+>fileName : Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
+>line : Symbol(line, Decl(APISample_linter.ts, 51, 13))
+>character : Symbol(character, Decl(APISample_linter.ts, 51, 19))
+>message : Symbol(message, Decl(APISample_linter.ts, 50, 34))
+    }
+}
+
+const fileNames = process.argv.slice(2);
+>fileNames : Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
+>process : Symbol(process, Decl(APISample_linter.ts, 7, 11))
+
+fileNames.forEach(fileName => {
+>fileNames : Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
+>fileName : 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 : Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
+>ts.createSourceFile : Symbol(ts.createSourceFile, Decl(typescript.d.ts, 1215, 107))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>createSourceFile : Symbol(ts.createSourceFile, Decl(typescript.d.ts, 1215, 107))
+>fileName : Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
+>readFileSync : Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
+>fileName : Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
+>ts.ScriptTarget.ES6 : Symbol(ts.ScriptTarget.ES6, Decl(typescript.d.ts, 1118, 16))
+>ts.ScriptTarget : Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
+>ts : Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>ScriptTarget : Symbol(ts.ScriptTarget, Decl(typescript.d.ts, 1115, 5))
+>ES6 : Symbol(ts.ScriptTarget.ES6, Decl(typescript.d.ts, 1118, 16))
+
+    // delint it
+    delint(sourceFile);
+>delint : Symbol(delint, Decl(APISample_linter.ts, 11, 33))
+>sourceFile : Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
+
+});

tests/baselines/reference/APISample_linter.types

@@ -7,211 +7,211 @@
  */
 
 declare var process: any;
->process : any, Symbol(process, Decl(APISample_linter.ts, 7, 11))
+>process : any
 
 declare var console: any;
->console : any, Symbol(console, Decl(APISample_linter.ts, 8, 11))
+>console : any
 
 declare var readFileSync: any;
->readFileSync : any, Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
+>readFileSync : any
 
 import * as ts from "typescript";
->ts : typeof ts, Symbol(ts, Decl(APISample_linter.ts, 11, 6))
+>ts : typeof ts
 
 export function delint(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, 1285, 5))
+>delint : (sourceFile: ts.SourceFile) => void
+>sourceFile : ts.SourceFile
+>ts : any
+>SourceFile : ts.SourceFile
 
     delintNode(sourceFile);
 >delintNode(sourceFile) : void
->delintNode : (node: ts.Node) => void, Symbol(delintNode, Decl(APISample_linter.ts, 14, 27))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
+>delintNode : (node: ts.Node) => void
+>sourceFile : ts.SourceFile
 
     function delintNode(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, 1245, 32))
+>delintNode : (node: ts.Node) => void
+>node : ts.Node
+>ts : any
+>Node : ts.Node
 
         switch (node.kind) {
->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))
+>node.kind : ts.SyntaxKind
+>node : ts.Node
+>kind : ts.SyntaxKind
 
             case ts.SyntaxKind.ForStatement:
->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))
+>ts.SyntaxKind.ForStatement : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>ForStatement : ts.SyntaxKind
 
             case ts.SyntaxKind.ForInStatement:
->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))
+>ts.SyntaxKind.ForInStatement : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>ForInStatement : ts.SyntaxKind
 
             case ts.SyntaxKind.WhileStatement:
->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))
+>ts.SyntaxKind.WhileStatement : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>WhileStatement : ts.SyntaxKind
 
             case ts.SyntaxKind.DoStatement:
->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))
+>ts.SyntaxKind.DoStatement : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>DoStatement : ts.SyntaxKind
 
                 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, 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).statement.kind : ts.SyntaxKind
+>(<ts.IterationStatement>node).statement : ts.Statement
 >(<ts.IterationStatement>node) : ts.IterationStatement
 ><ts.IterationStatement>node : ts.IterationStatement
->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))
+>ts : any
+>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
 
                     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, Symbol(report, Decl(APISample_linter.ts, 48, 5))
->node : ts.Node, Symbol(node, Decl(APISample_linter.ts, 16, 24))
+>report : (node: ts.Node, message: string) => void
+>node : ts.Node
 >"A looping statement's contents should be wrapped in a block body." : string
                 }
                 break;
 
             case ts.SyntaxKind.IfStatement:
->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))
+>ts.SyntaxKind.IfStatement : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>IfStatement : ts.SyntaxKind
 
                 let ifStatement = (<ts.IfStatement>node);
->ifStatement : ts.IfStatement, Symbol(ifStatement, Decl(APISample_linter.ts, 28, 19))
+>ifStatement : ts.IfStatement
 >(<ts.IfStatement>node) : ts.IfStatement
 ><ts.IfStatement>node : ts.IfStatement
->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))
+>ts : any
+>IfStatement : ts.IfStatement
+>node : ts.Node
 
                 if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) {
 >ifStatement.thenStatement.kind !== ts.SyntaxKind.Block : boolean
->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))
+>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
 
                     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, 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))
+>report : (node: ts.Node, message: string) => void
+>ifStatement.thenStatement : ts.Statement
+>ifStatement : ts.IfStatement
+>thenStatement : ts.Statement
 >"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, 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 : ts.Statement
+>ifStatement : ts.IfStatement
+>elseStatement : ts.Statement
 
                     ifStatement.elseStatement.kind !== ts.SyntaxKind.Block &&
 >ifStatement.elseStatement.kind !== ts.SyntaxKind.Block : boolean
->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.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.IfStatement) {
 >ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement : boolean
->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))
+>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
 
                     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, 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))
+>report : (node: ts.Node, message: string) => void
+>ifStatement.elseStatement : ts.Statement
+>ifStatement : ts.IfStatement
+>elseStatement : ts.Statement
 >"An else statement's contents should be wrapped in a block body." : string
                 }
                 break;
 
             case ts.SyntaxKind.BinaryExpression:
->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))
+>ts.SyntaxKind.BinaryExpression : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>BinaryExpression : ts.SyntaxKind
 
                 let op = (<ts.BinaryExpression>node).operatorToken.kind;
->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))
+>op : ts.SyntaxKind
+>(<ts.BinaryExpression>node).operatorToken.kind : ts.SyntaxKind
+>(<ts.BinaryExpression>node).operatorToken : ts.Node
 >(<ts.BinaryExpression>node) : ts.BinaryExpression
 ><ts.BinaryExpression>node : ts.BinaryExpression
->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))
+>ts : any
+>BinaryExpression : ts.BinaryExpression
+>node : ts.Node
+>operatorToken : ts.Node
+>kind : ts.SyntaxKind
 
                 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, 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
+>ts.SyntaxKind.EqualsEqualsToken : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>EqualsEqualsToken : ts.SyntaxKind
 >op == ts.SyntaxKind.ExclamationEqualsToken : boolean
->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))
+>op : ts.SyntaxKind
+>ts.SyntaxKind.ExclamationEqualsToken : ts.SyntaxKind
+>ts.SyntaxKind : typeof ts.SyntaxKind
+>ts : typeof ts
+>SyntaxKind : typeof ts.SyntaxKind
+>ExclamationEqualsToken : ts.SyntaxKind
 
                     report(node, "Use '===' and '!=='.")
 >report(node, "Use '===' and '!=='.") : void
->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))
+>report : (node: ts.Node, message: string) => void
+>node : ts.Node
 >"Use '===' and '!=='." : string
                 }
                 break;
@@ -219,57 +219,57 @@ export function delint(sourceFile: ts.SourceFile) {
 
         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, Symbol(ts.forEachChild, Decl(typescript.d.ts, 1214, 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, 1214, 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))
+>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
     }
 
     function report(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, 1245, 32))
->message : string, Symbol(message, Decl(APISample_linter.ts, 50, 34))
+>report : (node: ts.Node, message: string) => void
+>node : ts.Node
+>ts : any
+>Node : ts.Node
+>message : string
 
         let { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
->line : number, Symbol(line, Decl(APISample_linter.ts, 51, 13))
->character : number, Symbol(character, Decl(APISample_linter.ts, 51, 19))
+>line : number
+>character : number
 >sourceFile.getLineAndCharacterOfPosition(node.getStart()) : ts.LineAndCharacter
->sourceFile.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 13, 23))
->getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
+>sourceFile.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
+>sourceFile : ts.SourceFile
+>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
 >node.getStart() : number
->node.getStart : (sourceFile?: ts.SourceFile) => number, Symbol(ts.Node.getStart, Decl(typescript.d.ts, 1250, 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, 1250, 53))
+>node.getStart : (sourceFile?: ts.SourceFile) => number
+>node : ts.Node
+>getStart : (sourceFile?: ts.SourceFile) => number
 
         console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`);
 >console.log(`${sourceFile.fileName} (${line + 1},${character + 1}): ${message}`) : any
 >console.log : any
->console : any, Symbol(console, Decl(APISample_linter.ts, 8, 11))
+>console : any
 >log : any
 >`${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))
+>sourceFile.fileName : string
+>sourceFile : ts.SourceFile
+>fileName : string
 >line + 1 : number
->line : number, Symbol(line, Decl(APISample_linter.ts, 51, 13))
+>line : number
 >1 : number
 >character + 1 : number
->character : number, Symbol(character, Decl(APISample_linter.ts, 51, 19))
+>character : number
 >1 : number
->message : string, Symbol(message, Decl(APISample_linter.ts, 50, 34))
+>message : string
     }
 }
 
 const fileNames = process.argv.slice(2);
->fileNames : any, Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
+>fileNames : any
 >process.argv.slice(2) : any
 >process.argv.slice : any
 >process.argv : any
->process : any, Symbol(process, Decl(APISample_linter.ts, 7, 11))
+>process : any
 >argv : any
 >slice : any
 >2 : number
@@ -277,36 +277,36 @@ const fileNames = process.argv.slice(2);
 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, Symbol(fileNames, Decl(APISample_linter.ts, 56, 5))
+>fileNames : any
 >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, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
+>fileName : any
 
     // Parse a file
     let sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true);
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
+>sourceFile : ts.SourceFile
 >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, Symbol(ts.createSourceFile, Decl(typescript.d.ts, 1215, 107))
->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, 1215, 107))
->fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
+>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
 >readFileSync(fileName).toString() : any
 >readFileSync(fileName).toString : any
 >readFileSync(fileName) : any
->readFileSync : any, Symbol(readFileSync, Decl(APISample_linter.ts, 9, 11))
->fileName : any, Symbol(fileName, Decl(APISample_linter.ts, 57, 18))
+>readFileSync : any
+>fileName : any
 >toString : any
->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))
+>ts.ScriptTarget.ES6 : ts.ScriptTarget
+>ts.ScriptTarget : typeof ts.ScriptTarget
+>ts : typeof ts
+>ScriptTarget : typeof ts.ScriptTarget
+>ES6 : ts.ScriptTarget
 >true : boolean
 
     // delint it
     delint(sourceFile);
 >delint(sourceFile) : void
->delint : (sourceFile: ts.SourceFile) => void, Symbol(delint, Decl(APISample_linter.ts, 11, 33))
->sourceFile : ts.SourceFile, Symbol(sourceFile, Decl(APISample_linter.ts, 59, 7))
+>delint : (sourceFile: ts.SourceFile) => void
+>sourceFile : ts.SourceFile
 
 });

tests/baselines/reference/APISample_transform.symbols

@@ -0,0 +1,37 @@
+=== tests/cases/compiler/APISample_transform.ts ===
+
+/*
+ * Note: This test is a public API sample. The sample sources can be found 
+         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-simple-transform-function
+ *       Please log a "breaking change" issue for any API breaking change affecting this issue
+ */
+
+declare var console: any;
+>console : Symbol(console, Decl(APISample_transform.ts, 7, 11))
+
+import * as ts from "typescript";
+>ts : Symbol(ts, Decl(APISample_transform.ts, 9, 6))
+
+const source = "let x: string  = 'string'";
+>source : Symbol(source, Decl(APISample_transform.ts, 11, 5))
+
+let result = ts.transpile(source, { module: ts.ModuleKind.CommonJS });
+>result : Symbol(result, Decl(APISample_transform.ts, 13, 3))
+>ts.transpile : Symbol(ts.transpile, Decl(typescript.d.ts, 1752, 5))
+>ts : Symbol(ts, Decl(APISample_transform.ts, 9, 6))
+>transpile : Symbol(ts.transpile, Decl(typescript.d.ts, 1752, 5))
+>source : Symbol(source, Decl(APISample_transform.ts, 11, 5))
+>module : Symbol(module, Decl(APISample_transform.ts, 13, 35))
+>ts.ModuleKind.CommonJS : Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
+>ts.ModuleKind : Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
+>ts : Symbol(ts, Decl(APISample_transform.ts, 9, 6))
+>ModuleKind : Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
+>CommonJS : Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
+
+console.log(JSON.stringify(result));
+>console : Symbol(console, Decl(APISample_transform.ts, 7, 11))
+>JSON.stringify : 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 : Symbol(JSON, Decl(lib.d.ts, 955, 42), Decl(lib.d.ts, 1000, 11))
+>stringify : 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 : Symbol(result, Decl(APISample_transform.ts, 13, 3))
+

tests/baselines/reference/APISample_transform.types

@@ -7,38 +7,38 @@
  */
 
 declare var console: any;
->console : any, Symbol(console, Decl(APISample_transform.ts, 7, 11))
+>console : any
 
 import * as ts from "typescript";
->ts : typeof ts, Symbol(ts, Decl(APISample_transform.ts, 9, 6))
+>ts : typeof ts
 
 const source = "let x: string  = 'string'";
->source : string, Symbol(source, Decl(APISample_transform.ts, 11, 5))
+>source : string
 >"let x: string  = 'string'" : string
 
 let result = ts.transpile(source, { module: ts.ModuleKind.CommonJS });
->result : string, Symbol(result, Decl(APISample_transform.ts, 13, 3))
+>result : string
 >ts.transpile(source, { module: ts.ModuleKind.CommonJS }) : string
->ts.transpile : (input: string, compilerOptions?: ts.CompilerOptions, fileName?: string, diagnostics?: ts.Diagnostic[]) => string, Symbol(ts.transpile, Decl(typescript.d.ts, 1752, 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, 1752, 5))
->source : string, Symbol(source, Decl(APISample_transform.ts, 11, 5))
+>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
 >{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: 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))
+>module : ts.ModuleKind
+>ts.ModuleKind.CommonJS : ts.ModuleKind
+>ts.ModuleKind : typeof ts.ModuleKind
+>ts : typeof ts
+>ModuleKind : typeof ts.ModuleKind
+>CommonJS : ts.ModuleKind
 
 console.log(JSON.stringify(result));
 >console.log(JSON.stringify(result)) : any
 >console.log : any
->console : any, Symbol(console, Decl(APISample_transform.ts, 7, 11))
+>console : any
 >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; }, 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))
+>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
 

tests/baselines/reference/APISample_watcher.symbols

@@ -0,0 +1,322 @@
+=== tests/cases/compiler/APISample_watcher.ts ===
+
+/*
+ * Note: This test is a public API sample. The sample sources can be found 
+         at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#incremental-build-support-using-the-language-services
+ *       Please log a "breaking change" issue for any API breaking change affecting this issue
+ */
+
+declare var process: any;
+>process : Symbol(process, Decl(APISample_watcher.ts, 7, 11))
+
+declare var console: any;
+>console : Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+
+declare var fs: any;
+>fs : Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+
+declare var path: any;
+>path : Symbol(path, Decl(APISample_watcher.ts, 10, 11))
+
+import * as ts from "typescript";
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+
+function watch(rootFileNames: string[], options: ts.CompilerOptions) {
+>watch : Symbol(watch, Decl(APISample_watcher.ts, 12, 33))
+>rootFileNames : Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
+>options : Symbol(options, Decl(APISample_watcher.ts, 14, 39))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>CompilerOptions : Symbol(ts.CompilerOptions, Decl(typescript.d.ts, 1074, 5))
+
+    const files: ts.Map<{ version: number }> = {};
+>files : Symbol(files, Decl(APISample_watcher.ts, 15, 9))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>Map : Symbol(ts.Map, Decl(typescript.d.ts, 15, 29))
+>version : Symbol(version, Decl(APISample_watcher.ts, 15, 25))
+
+    // initialize the list of files
+    rootFileNames.forEach(fileName => {
+>rootFileNames.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>rootFileNames : Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
+
+        files[fileName] = { version: 0 };
+>files : Symbol(files, Decl(APISample_watcher.ts, 15, 9))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
+>version : Symbol(version, Decl(APISample_watcher.ts, 19, 27))
+
+    });
+
+    // Create the language service host to allow the LS to communicate with the host
+    const servicesHost: ts.LanguageServiceHost = {
+>servicesHost : Symbol(servicesHost, Decl(APISample_watcher.ts, 23, 9))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>LanguageServiceHost : Symbol(ts.LanguageServiceHost, Decl(typescript.d.ts, 1318, 5))
+
+        getScriptFileNames: () => rootFileNames,
+>getScriptFileNames : Symbol(getScriptFileNames, Decl(APISample_watcher.ts, 23, 50))
+>rootFileNames : Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
+
+        getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(),
+>getScriptVersion : Symbol(getScriptVersion, Decl(APISample_watcher.ts, 24, 48))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
+>files : Symbol(files, Decl(APISample_watcher.ts, 15, 9))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
+>files[fileName].version.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+>files[fileName].version : Symbol(version, Decl(APISample_watcher.ts, 15, 25))
+>files : Symbol(files, Decl(APISample_watcher.ts, 15, 9))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
+>version : Symbol(version, Decl(APISample_watcher.ts, 15, 25))
+>toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
+
+        getScriptSnapshot: (fileName) => {
+>getScriptSnapshot : Symbol(getScriptSnapshot, Decl(APISample_watcher.ts, 25, 94))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
+
+            if (!fs.existsSync(fileName)) {
+>fs : Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
+
+                return undefined;
+>undefined : Symbol(undefined)
+            }
+
+            return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());
+>ts.ScriptSnapshot.fromString : Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1311, 27))
+>ts.ScriptSnapshot : Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1310, 5))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>ScriptSnapshot : Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1310, 5))
+>fromString : Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1311, 27))
+>fs : Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
+
+        },
+        getCurrentDirectory: () => process.cwd(),
+>getCurrentDirectory : Symbol(getCurrentDirectory, Decl(APISample_watcher.ts, 32, 10))
+>process : Symbol(process, Decl(APISample_watcher.ts, 7, 11))
+
+        getCompilationSettings: () => options,
+>getCompilationSettings : Symbol(getCompilationSettings, Decl(APISample_watcher.ts, 33, 49))
+>options : Symbol(options, Decl(APISample_watcher.ts, 14, 39))
+
+        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+>getDefaultLibFileName : Symbol(getDefaultLibFileName, Decl(APISample_watcher.ts, 34, 46))
+>options : Symbol(options, Decl(APISample_watcher.ts, 35, 32))
+>ts.getDefaultLibFilePath : Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1760, 44))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>getDefaultLibFilePath : Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1760, 44))
+>options : Symbol(options, Decl(APISample_watcher.ts, 35, 32))
+
+    };
+
+    // Create the language service files
+    const services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry())
+>services : Symbol(services, Decl(APISample_watcher.ts, 39, 9))
+>ts.createLanguageService : Symbol(ts.createLanguageService, Decl(typescript.d.ts, 1758, 97))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>createLanguageService : Symbol(ts.createLanguageService, Decl(typescript.d.ts, 1758, 97))
+>servicesHost : Symbol(servicesHost, Decl(APISample_watcher.ts, 23, 9))
+>ts.createDocumentRegistry : Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1756, 193))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>createDocumentRegistry : Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1756, 193))
+
+    // Now let's watch the files
+    rootFileNames.forEach(fileName => {
+>rootFileNames.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>rootFileNames : Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+
+        // First time around, emit all files
+        emitFile(fileName);
+>emitFile : Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+
+        // Add a watch on the file to handle next change
+        fs.watchFile(fileName,
+>fs : Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+
+            { persistent: true, interval: 250 },
+>persistent : Symbol(persistent, Decl(APISample_watcher.ts, 48, 13))
+>interval : Symbol(interval, Decl(APISample_watcher.ts, 48, 31))
+
+            (curr, prev) => {
+>curr : Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
+>prev : Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
+
+                // Check timestamp
+                if (+curr.mtime <= +prev.mtime) {
+>curr : Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
+>prev : Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
+
+                    return;
+                }
+
+                // Update the version to signal a change in the file
+                files[fileName].version++;
+>files[fileName].version : Symbol(version, Decl(APISample_watcher.ts, 15, 25))
+>files : Symbol(files, Decl(APISample_watcher.ts, 15, 9))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+>version : Symbol(version, Decl(APISample_watcher.ts, 15, 25))
+
+                // write the changes to disk
+                emitFile(fileName);
+>emitFile : Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+
+            });
+    });
+
+    function emitFile(fileName: string) {
+>emitFile : Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+
+        let output = services.getEmitOutput(fileName);
+>output : Symbol(output, Decl(APISample_watcher.ts, 64, 11))
+>services.getEmitOutput : Symbol(ts.LanguageService.getEmitOutput, Decl(typescript.d.ts, 1362, 132))
+>services : Symbol(services, Decl(APISample_watcher.ts, 39, 9))
+>getEmitOutput : Symbol(ts.LanguageService.getEmitOutput, Decl(typescript.d.ts, 1362, 132))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+
+        if (!output.emitSkipped) {
+>output.emitSkipped : Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1565, 34))
+>output : Symbol(output, Decl(APISample_watcher.ts, 64, 11))
+>emitSkipped : Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1565, 34))
+
+            console.log(`Emitting ${fileName}`);
+>console : Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+        }
+        else {
+            console.log(`Emitting ${fileName} failed`);
+>console : Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+
+            logErrors(fileName);
+>logErrors : Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+        }
+
+        output.outputFiles.forEach(o => {
+>output.outputFiles.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>output.outputFiles : Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1564, 26))
+>output : Symbol(output, Decl(APISample_watcher.ts, 64, 11))
+>outputFiles : Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1564, 26))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>o : Symbol(o, Decl(APISample_watcher.ts, 74, 35))
+
+            fs.writeFileSync(o.name, o.text, "utf8");
+>fs : Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>o.name : Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1573, 26))
+>o : Symbol(o, Decl(APISample_watcher.ts, 74, 35))
+>name : Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1573, 26))
+>o.text : Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1575, 36))
+>o : Symbol(o, Decl(APISample_watcher.ts, 74, 35))
+>text : Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1575, 36))
+
+        });
+    }
+
+    function logErrors(fileName: string) {
+>logErrors : Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
+
+        let allDiagnostics = services.getCompilerOptionsDiagnostics()
+>allDiagnostics : Symbol(allDiagnostics, Decl(APISample_watcher.ts, 80, 11))
+>services.getCompilerOptionsDiagnostics()            .concat(services.getSyntacticDiagnostics(fileName))            .concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>services.getCompilerOptionsDiagnostics()            .concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>services.getCompilerOptionsDiagnostics : Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1336, 63))
+>services : Symbol(services, Decl(APISample_watcher.ts, 39, 9))
+>getCompilerOptionsDiagnostics : Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1336, 63))
+
+            .concat(services.getSyntacticDiagnostics(fileName))
+>concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>services.getSyntacticDiagnostics : Symbol(ts.LanguageService.getSyntacticDiagnostics, Decl(typescript.d.ts, 1334, 37))
+>services : Symbol(services, Decl(APISample_watcher.ts, 39, 9))
+>getSyntacticDiagnostics : Symbol(ts.LanguageService.getSyntacticDiagnostics, Decl(typescript.d.ts, 1334, 37))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
+
+            .concat(services.getSemanticDiagnostics(fileName));
+>concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>services.getSemanticDiagnostics : Symbol(ts.LanguageService.getSemanticDiagnostics, Decl(typescript.d.ts, 1335, 64))
+>services : Symbol(services, Decl(APISample_watcher.ts, 39, 9))
+>getSemanticDiagnostics : Symbol(ts.LanguageService.getSemanticDiagnostics, Decl(typescript.d.ts, 1335, 64))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
+
+        allDiagnostics.forEach(diagnostic => {
+>allDiagnostics.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>allDiagnostics : Symbol(allDiagnostics, Decl(APISample_watcher.ts, 80, 11))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
+>diagnostic : Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
+
+            let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+>message : Symbol(message, Decl(APISample_watcher.ts, 85, 15))
+>ts.flattenDiagnosticMessageText : Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1224, 67))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>flattenDiagnosticMessageText : Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1224, 67))
+>diagnostic.messageText : Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
+>diagnostic : Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
+>messageText : Symbol(ts.Diagnostic.messageText, Decl(typescript.d.ts, 1065, 23))
+
+            if (diagnostic.file) {
+>diagnostic.file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>diagnostic : Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
+>file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+
+                let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+>line : Symbol(line, Decl(APISample_watcher.ts, 87, 21))
+>character : Symbol(character, Decl(APISample_watcher.ts, 87, 27))
+>diagnostic.file.getLineAndCharacterOfPosition : Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
+>diagnostic.file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>diagnostic : Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
+>file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>getLineAndCharacterOfPosition : Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
+>diagnostic.start : Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
+>diagnostic : Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
+>start : Symbol(ts.Diagnostic.start, Decl(typescript.d.ts, 1063, 25))
+
+                console.log(`  Error ${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+>console : Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>diagnostic.file.fileName : Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
+>diagnostic.file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>diagnostic : Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
+>file : Symbol(ts.Diagnostic.file, Decl(typescript.d.ts, 1062, 26))
+>fileName : Symbol(ts.SourceFile.fileName, Decl(typescript.d.ts, 743, 29))
+>line : Symbol(line, Decl(APISample_watcher.ts, 87, 21))
+>character : Symbol(character, Decl(APISample_watcher.ts, 87, 27))
+>message : Symbol(message, Decl(APISample_watcher.ts, 85, 15))
+            }
+            else {
+                console.log(`  Error: ${message}`);
+>console : Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>message : Symbol(message, Decl(APISample_watcher.ts, 85, 15))
+            }
+        });
+    }
+}
+
+// Initialize files constituting the program as all .ts files in the current directory
+const currentDirectoryFiles = fs.readdirSync(process.cwd()).
+>currentDirectoryFiles : Symbol(currentDirectoryFiles, Decl(APISample_watcher.ts, 98, 5))
+>fs : Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>process : Symbol(process, Decl(APISample_watcher.ts, 7, 11))
+
+    filter(fileName=> fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts");
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+>fileName : Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+
+// Start the watcher
+watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS });
+>watch : Symbol(watch, Decl(APISample_watcher.ts, 12, 33))
+>currentDirectoryFiles : Symbol(currentDirectoryFiles, Decl(APISample_watcher.ts, 98, 5))
+>module : Symbol(module, Decl(APISample_watcher.ts, 102, 30))
+>ts.ModuleKind.CommonJS : Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
+>ts.ModuleKind : Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
+>ts : Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>ModuleKind : Symbol(ts.ModuleKind, Decl(typescript.d.ts, 1106, 5))
+>CommonJS : Symbol(ts.ModuleKind.CommonJS, Decl(typescript.d.ts, 1108, 17))
+

tests/baselines/reference/APISample_watcher.types

@@ -7,200 +7,200 @@
  */
 
 declare var process: any;
->process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
+>process : any
 
 declare var console: any;
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>console : any
 
 declare var fs: any;
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fs : any
 
 declare var path: any;
->path : any, Symbol(path, Decl(APISample_watcher.ts, 10, 11))
+>path : any
 
 import * as ts from "typescript";
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
+>ts : typeof ts
 
 function watch(rootFileNames: string[], options: 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))
+>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void
+>rootFileNames : string[]
+>options : ts.CompilerOptions
+>ts : any
+>CompilerOptions : ts.CompilerOptions
 
     const files: ts.Map<{ 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))
+>files : ts.Map<{ version: number; }>
+>ts : any
+>Map : ts.Map<T>
+>version : number
 >{} : { [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, 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))
+>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
 >fileName => {        files[fileName] = { version: 0 };    } : (fileName: string) => void
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
+>fileName : string
 
         files[fileName] = { version: 0 };
 >files[fileName] = { version: 0 } : { version: number; }
 >files[fileName] : { version: number; }
->files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 18, 26))
+>files : ts.Map<{ version: number; }>
+>fileName : string
 >{ version: 0 } : { version: number; }
->version : number, Symbol(version, Decl(APISample_watcher.ts, 19, 27))
+>version : number
 >0 : number
 
     });
 
     // Create the language service host to allow the LS to communicate with the host
     const servicesHost: 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, 1318, 5))
+>servicesHost : ts.LanguageServiceHost
+>ts : any
+>LanguageServiceHost : ts.LanguageServiceHost
 >{        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[], Symbol(getScriptFileNames, Decl(APISample_watcher.ts, 23, 50))
+>getScriptFileNames : () => string[]
 >() => rootFileNames : () => string[]
->rootFileNames : string[], Symbol(rootFileNames, Decl(APISample_watcher.ts, 14, 15))
+>rootFileNames : string[]
 
         getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(),
->getScriptVersion : (fileName: string) => string, Symbol(getScriptVersion, Decl(APISample_watcher.ts, 24, 48))
+>getScriptVersion : (fileName: string) => string
 >(fileName) => files[fileName] && files[fileName].version.toString() : (fileName: string) => string
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
+>fileName : string
 >files[fileName] && files[fileName].version.toString() : string
 >files[fileName] : { version: number; }
->files : ts.Map<{ version: number; }>, Symbol(files, Decl(APISample_watcher.ts, 15, 9))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 25, 27))
+>files : ts.Map<{ version: number; }>
+>fileName : string
 >files[fileName].version.toString() : string
->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.toString : (radix?: number) => string
+>files[fileName].version : number
 >files[fileName] : { version: number; }
->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))
+>files : ts.Map<{ version: number; }>
+>fileName : string
+>version : number
+>toString : (radix?: number) => string
 
         getScriptSnapshot: (fileName) => {
->getScriptSnapshot : (fileName: string) => ts.IScriptSnapshot, Symbol(getScriptSnapshot, Decl(APISample_watcher.ts, 25, 94))
+>getScriptSnapshot : (fileName: string) => ts.IScriptSnapshot
 >(fileName) => {            if (!fs.existsSync(fileName)) {                return undefined;            }            return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName).toString());        } : (fileName: string) => ts.IScriptSnapshot
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
+>fileName : string
 
             if (!fs.existsSync(fileName)) {
 >!fs.existsSync(fileName) : boolean
 >fs.existsSync(fileName) : any
 >fs.existsSync : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fs : any
 >existsSync : any
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
+>fileName : string
 
                 return undefined;
->undefined : undefined, Symbol(undefined)
+>undefined : 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, Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1311, 27))
->ts.ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1310, 5))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->ScriptSnapshot : typeof ts.ScriptSnapshot, Symbol(ts.ScriptSnapshot, Decl(typescript.d.ts, 1310, 5))
->fromString : (text: string) => ts.IScriptSnapshot, Symbol(ts.ScriptSnapshot.fromString, Decl(typescript.d.ts, 1311, 27))
+>ts.ScriptSnapshot.fromString : (text: string) => ts.IScriptSnapshot
+>ts.ScriptSnapshot : typeof ts.ScriptSnapshot
+>ts : typeof ts
+>ScriptSnapshot : typeof ts.ScriptSnapshot
+>fromString : (text: string) => ts.IScriptSnapshot
 >fs.readFileSync(fileName).toString() : any
 >fs.readFileSync(fileName).toString : any
 >fs.readFileSync(fileName) : any
 >fs.readFileSync : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fs : any
 >readFileSync : any
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 26, 28))
+>fileName : string
 >toString : any
 
         },
         getCurrentDirectory: () => process.cwd(),
->getCurrentDirectory : () => any, Symbol(getCurrentDirectory, Decl(APISample_watcher.ts, 32, 10))
+>getCurrentDirectory : () => any
 >() => process.cwd() : () => any
 >process.cwd() : any
 >process.cwd : any
->process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
+>process : any
 >cwd : any
 
         getCompilationSettings: () => options,
->getCompilationSettings : () => ts.CompilerOptions, Symbol(getCompilationSettings, Decl(APISample_watcher.ts, 33, 49))
+>getCompilationSettings : () => ts.CompilerOptions
 >() => options : () => ts.CompilerOptions
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 14, 39))
+>options : ts.CompilerOptions
 
         getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
->getDefaultLibFileName : (options: ts.CompilerOptions) => string, Symbol(getDefaultLibFileName, Decl(APISample_watcher.ts, 34, 46))
+>getDefaultLibFileName : (options: ts.CompilerOptions) => string
 >(options) => ts.getDefaultLibFilePath(options) : (options: ts.CompilerOptions) => string
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 35, 32))
+>options : ts.CompilerOptions
 >ts.getDefaultLibFilePath(options) : string
->ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1760, 44))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->getDefaultLibFilePath : (options: ts.CompilerOptions) => string, Symbol(ts.getDefaultLibFilePath, Decl(typescript.d.ts, 1760, 44))
->options : ts.CompilerOptions, Symbol(options, Decl(APISample_watcher.ts, 35, 32))
+>ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string
+>ts : typeof ts
+>getDefaultLibFilePath : (options: ts.CompilerOptions) => string
+>options : ts.CompilerOptions
 
     };
 
     // Create the language service files
     const services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry())
->services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
+>services : ts.LanguageService
 >ts.createLanguageService(servicesHost, ts.createDocumentRegistry()) : ts.LanguageService
->ts.createLanguageService : (host: ts.LanguageServiceHost, documentRegistry?: ts.DocumentRegistry) => ts.LanguageService, Symbol(ts.createLanguageService, Decl(typescript.d.ts, 1758, 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, 1758, 97))
->servicesHost : ts.LanguageServiceHost, Symbol(servicesHost, Decl(APISample_watcher.ts, 23, 9))
+>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.createDocumentRegistry() : ts.DocumentRegistry
->ts.createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1756, 193))
->ts : typeof ts, Symbol(ts, Decl(APISample_watcher.ts, 12, 6))
->createDocumentRegistry : () => ts.DocumentRegistry, Symbol(ts.createDocumentRegistry, Decl(typescript.d.ts, 1756, 193))
+>ts.createDocumentRegistry : () => ts.DocumentRegistry
+>ts : typeof ts
+>createDocumentRegistry : () => ts.DocumentRegistry
 
     // 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, 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))
+>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
 >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, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+>fileName : string
 
         // First time around, emit all files
         emitFile(fileName);
 >emitFile(fileName) : void
->emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+>emitFile : (fileName: string) => void
+>fileName : string
 
         // 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, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fs : any
 >watchFile : any
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+>fileName : string
 
             { persistent: true, interval: 250 },
 >{ persistent: true, interval: 250 } : { persistent: boolean; interval: number; }
->persistent : boolean, Symbol(persistent, Decl(APISample_watcher.ts, 48, 13))
+>persistent : boolean
 >true : boolean
->interval : number, Symbol(interval, Decl(APISample_watcher.ts, 48, 31))
+>interval : number
 >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, Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
->prev : any, Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
+>curr : any
+>prev : any
 
                 // Check timestamp
                 if (+curr.mtime <= +prev.mtime) {
 >+curr.mtime <= +prev.mtime : boolean
 >+curr.mtime : number
 >curr.mtime : any
->curr : any, Symbol(curr, Decl(APISample_watcher.ts, 49, 13))
+>curr : any
 >mtime : any
 >+prev.mtime : number
 >prev.mtime : any
->prev : any, Symbol(prev, Decl(APISample_watcher.ts, 49, 18))
+>prev : any
 >mtime : any
 
                     return;
@@ -209,183 +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, Symbol(version, Decl(APISample_watcher.ts, 15, 25))
+>files[fileName].version : number
 >files[fileName] : { 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))
+>files : ts.Map<{ version: number; }>
+>fileName : string
+>version : number
 
                 // write the changes to disk
                 emitFile(fileName);
 >emitFile(fileName) : void
->emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 42, 26))
+>emitFile : (fileName: string) => void
+>fileName : string
 
             });
     });
 
     function emitFile(fileName: string) {
->emitFile : (fileName: string) => void, Symbol(emitFile, Decl(APISample_watcher.ts, 61, 7))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+>emitFile : (fileName: string) => void
+>fileName : string
 
         let output = services.getEmitOutput(fileName);
->output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
+>output : ts.EmitOutput
 >services.getEmitOutput(fileName) : ts.EmitOutput
->services.getEmitOutput : (fileName: string) => ts.EmitOutput, Symbol(ts.LanguageService.getEmitOutput, Decl(typescript.d.ts, 1362, 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, 1362, 132))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+>services.getEmitOutput : (fileName: string) => ts.EmitOutput
+>services : ts.LanguageService
+>getEmitOutput : (fileName: string) => ts.EmitOutput
+>fileName : string
 
         if (!output.emitSkipped) {
 >!output.emitSkipped : boolean
->output.emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1565, 34))
->output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
->emitSkipped : boolean, Symbol(ts.EmitOutput.emitSkipped, Decl(typescript.d.ts, 1565, 34))
+>output.emitSkipped : boolean
+>output : ts.EmitOutput
+>emitSkipped : boolean
 
             console.log(`Emitting ${fileName}`);
 >console.log(`Emitting ${fileName}`) : any
 >console.log : any
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>console : any
 >log : any
 >`Emitting ${fileName}` : string
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+>fileName : string
         }
         else {
             console.log(`Emitting ${fileName} failed`);
 >console.log(`Emitting ${fileName} failed`) : any
 >console.log : any
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>console : any
 >log : any
 >`Emitting ${fileName} failed` : string
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+>fileName : string
 
             logErrors(fileName);
 >logErrors(fileName) : void
->logErrors : (fileName: string) => void, Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 63, 22))
+>logErrors : (fileName: string) => void
+>fileName : string
         }
 
         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, Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95))
->output.outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1564, 26))
->output : ts.EmitOutput, Symbol(output, Decl(APISample_watcher.ts, 64, 11))
->outputFiles : ts.OutputFile[], Symbol(ts.EmitOutput.outputFiles, Decl(typescript.d.ts, 1564, 26))
->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.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
 >o => {            fs.writeFileSync(o.name, o.text, "utf8");        } : (o: ts.OutputFile) => void
->o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
+>o : ts.OutputFile
 
             fs.writeFileSync(o.name, o.text, "utf8");
 >fs.writeFileSync(o.name, o.text, "utf8") : any
 >fs.writeFileSync : any
->fs : any, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fs : any
 >writeFileSync : any
->o.name : string, Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1573, 26))
->o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
->name : string, Symbol(ts.OutputFile.name, Decl(typescript.d.ts, 1573, 26))
->o.text : string, Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1575, 36))
->o : ts.OutputFile, Symbol(o, Decl(APISample_watcher.ts, 74, 35))
->text : string, Symbol(ts.OutputFile.text, Decl(typescript.d.ts, 1575, 36))
+>o.name : string
+>o : ts.OutputFile
+>name : string
+>o.text : string
+>o : ts.OutputFile
+>text : string
 >"utf8" : string
 
         });
     }
 
     function logErrors(fileName: string) {
->logErrors : (fileName: string) => void, Symbol(logErrors, Decl(APISample_watcher.ts, 77, 5))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
+>logErrors : (fileName: string) => void
+>fileName : string
 
         let allDiagnostics = services.getCompilerOptionsDiagnostics()
->allDiagnostics : ts.Diagnostic[], Symbol(allDiagnostics, Decl(APISample_watcher.ts, 80, 11))
+>allDiagnostics : ts.Diagnostic[]
 >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[]; }, Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46))
+>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)) : 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()            .concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
 >services.getCompilerOptionsDiagnostics() : ts.Diagnostic[]
->services.getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1336, 63))
->services : ts.LanguageService, Symbol(services, Decl(APISample_watcher.ts, 39, 9))
->getCompilerOptionsDiagnostics : () => ts.Diagnostic[], Symbol(ts.LanguageService.getCompilerOptionsDiagnostics, Decl(typescript.d.ts, 1336, 63))
+>services.getCompilerOptionsDiagnostics : () => ts.Diagnostic[]
+>services : ts.LanguageService
+>getCompilerOptionsDiagnostics : () => ts.Diagnostic[]
 
             .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))
+>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
 >services.getSyntacticDiagnostics(fileName) : ts.Diagnostic[]
->services.getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSyntacticDiagnostics, Decl(typescript.d.ts, 1334, 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, 1334, 37))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
+>services.getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[]
+>services : ts.LanguageService
+>getSyntacticDiagnostics : (fileName: string) => ts.Diagnostic[]
+>fileName : string
 
             .concat(services.getSemanticDiagnostics(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))
+>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
 >services.getSemanticDiagnostics(fileName) : ts.Diagnostic[]
->services.getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[], Symbol(ts.LanguageService.getSemanticDiagnostics, Decl(typescript.d.ts, 1335, 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, 1335, 64))
->fileName : string, Symbol(fileName, Decl(APISample_watcher.ts, 79, 23))
+>services.getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[]
+>services : ts.LanguageService
+>getSemanticDiagnostics : (fileName: string) => ts.Diagnostic[]
+>fileName : string
 
         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, 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))
+>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
 >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, Symbol(diagnostic, Decl(APISample_watcher.ts, 84, 31))
+>diagnostic : ts.Diagnostic
 
             let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
->message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
+>message : string
 >ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n") : string
->ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string, Symbol(ts.flattenDiagnosticMessageText, Decl(typescript.d.ts, 1224, 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, 1224, 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))
+>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
 >"\n" : string
 
             if (diagnostic.file) {
->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))
+>diagnostic.file : ts.SourceFile
+>diagnostic : ts.Diagnostic
+>file : ts.SourceFile
 
                 let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
->line : number, Symbol(line, Decl(APISample_watcher.ts, 87, 21))
->character : number, Symbol(character, Decl(APISample_watcher.ts, 87, 27))
+>line : number
+>character : number
 >diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : ts.LineAndCharacter
->diagnostic.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter, Symbol(ts.SourceFile.getLineAndCharacterOfPosition, Decl(typescript.d.ts, 1286, 26))
->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, 1286, 26))
->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))
+>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
 
                 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, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>console : any
 >log : any
 >`  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))
+>diagnostic.file.fileName : string
+>diagnostic.file : ts.SourceFile
+>diagnostic : ts.Diagnostic
+>file : ts.SourceFile
+>fileName : string
 >line + 1 : number
->line : number, Symbol(line, Decl(APISample_watcher.ts, 87, 21))
+>line : number
 >1 : number
 >character + 1 : number
->character : number, Symbol(character, Decl(APISample_watcher.ts, 87, 27))
+>character : number
 >1 : number
->message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
+>message : string
             }
             else {
                 console.log(`  Error: ${message}`);
 >console.log(`  Error: ${message}`) : any
 >console.log : any
->console : any, Symbol(console, Decl(APISample_watcher.ts, 8, 11))
+>console : any
 >log : any
 >`  Error: ${message}` : string
->message : string, Symbol(message, Decl(APISample_watcher.ts, 85, 15))
+>message : string
             }
         });
     }
@@ -393,36 +393,36 @@ 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, Symbol(currentDirectoryFiles, Decl(APISample_watcher.ts, 98, 5))
+>currentDirectoryFiles : any
 >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, Symbol(fs, Decl(APISample_watcher.ts, 9, 11))
+>fs : any
 >readdirSync : any
 >process.cwd() : any
 >process.cwd : any
->process : any, Symbol(process, Decl(APISample_watcher.ts, 7, 11))
+>process : any
 >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, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+>fileName : any
 >fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
 >fileName.length >= 3 : boolean
 >fileName.length : any
->fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+>fileName : any
 >length : any
 >3 : number
 >fileName.substr(fileName.length - 3, 3) === ".ts" : boolean
 >fileName.substr(fileName.length - 3, 3) : any
 >fileName.substr : any
->fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+>fileName : any
 >substr : any
 >fileName.length - 3 : number
 >fileName.length : any
->fileName : any, Symbol(fileName, Decl(APISample_watcher.ts, 99, 11))
+>fileName : any
 >length : any
 >3 : number
 >3 : number
@@ -431,13 +431,13 @@ const currentDirectoryFiles = fs.readdirSync(process.cwd()).
 // Start the watcher
 watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS });
 >watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS }) : void
->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))
+>watch : (rootFileNames: string[], options: ts.CompilerOptions) => void
+>currentDirectoryFiles : any
 >{ module: ts.ModuleKind.CommonJS } : { [x: string]: ts.ModuleKind; module: 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))
+>module : ts.ModuleKind
+>ts.ModuleKind.CommonJS : ts.ModuleKind
+>ts.ModuleKind : typeof ts.ModuleKind
+>ts : typeof ts
+>ModuleKind : typeof ts.ModuleKind
+>CommonJS : ts.ModuleKind
 

tests/baselines/reference/AmbientModuleAndAmbientFunctionWithTheSameNameAndCommonRoot.symbols

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

tests/baselines/reference/AmbientModuleAndAmbientFunctionWithTheSameNameAndCommonRoot.types

@@ -1,33 +1,33 @@
 === tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
 declare module Point {
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+>Point : typeof Point
 
     export var Origin: { 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))
+>Origin : { x: number; y: number; }
+>x : number
+>y : number
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/function.d.ts ===
 declare function 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))
+>Point : typeof Point
+>x : number
+>y : number
 
 === tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
 var 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))
->x : number, Symbol(x, Decl(test.ts, 0, 9))
->y : number, Symbol(y, Decl(test.ts, 0, 20))
+>cl : { x: number; y: number; }
+>x : number
+>y : number
 
 var cl = Point();
->cl : { x: number; y: number; }, Symbol(cl, Decl(test.ts, 0, 3), Decl(test.ts, 1, 3), Decl(test.ts, 2, 3))
+>cl : { x: number; y: number; }
 >Point() : { x: number; y: number; }
->Point : typeof Point, Symbol(Point, Decl(module.d.ts, 0, 0), Decl(function.d.ts, 0, 0))
+>Point : typeof Point
 
 var cl = Point.Origin;
->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))
+>cl : { x: number; y: number; }
+>Point.Origin : { x: number; y: number; }
+>Point : typeof Point
+>Origin : { x: number; y: number; }
 

tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.symbols

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

tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types

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

tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.symbols

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

tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types

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

tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.symbols

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

tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.types

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

tests/baselines/reference/ArrowFunction4.symbols

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

tests/baselines/reference/ArrowFunction4.types

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

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.symbols

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

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

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

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.symbols

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

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types

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

tests/baselines/reference/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.symbols

@@ -0,0 +1,3 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.ts ===
+ 
+No type information for this code.

tests/baselines/reference/ES3For-ofTypeCheck2.symbols

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

tests/baselines/reference/ES3For-ofTypeCheck2.types

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

tests/baselines/reference/ES3For-ofTypeCheck6.symbols

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

tests/baselines/reference/ES3For-ofTypeCheck6.types

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

tests/baselines/reference/ES5For-of10.symbols

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

tests/baselines/reference/ES5For-of10.types

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

tests/baselines/reference/ES5For-of11.symbols

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

tests/baselines/reference/ES5For-of11.types

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

tests/baselines/reference/ES5For-of13.symbols

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

tests/baselines/reference/ES5For-of13.types

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

tests/baselines/reference/ES5For-of14.symbols

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

tests/baselines/reference/ES5For-of14.types

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

tests/baselines/reference/ES5For-of15.symbols

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

tests/baselines/reference/ES5For-of15.types

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

tests/baselines/reference/ES5For-of16.symbols

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

tests/baselines/reference/ES5For-of16.types

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

tests/baselines/reference/ES5For-of18.symbols

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

tests/baselines/reference/ES5For-of18.types

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

tests/baselines/reference/ES5For-of19.symbols

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

tests/baselines/reference/ES5For-of19.types

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

tests/baselines/reference/ES5For-of2.symbols

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

tests/baselines/reference/ES5For-of2.types

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

tests/baselines/reference/ES5For-of21.symbols

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

tests/baselines/reference/ES5For-of21.types

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

tests/baselines/reference/ES5For-of24.symbols

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

tests/baselines/reference/ES5For-of24.types

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

tests/baselines/reference/ES5For-of25.symbols

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

tests/baselines/reference/ES5For-of25.types

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

tests/baselines/reference/ES5For-of3.symbols

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

tests/baselines/reference/ES5For-of3.types

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

tests/baselines/reference/ES5For-of4.symbols

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

tests/baselines/reference/ES5For-of4.types

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

tests/baselines/reference/ES5For-of5.symbols

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

tests/baselines/reference/ES5For-of5.types

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

tests/baselines/reference/ES5For-of6.symbols

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

tests/baselines/reference/ES5For-of6.types

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

tests/baselines/reference/ES5For-of9.symbols

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

tests/baselines/reference/ES5For-of9.types

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

tests/baselines/reference/ES5For-ofTypeCheck1.symbols

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

tests/baselines/reference/ES5For-ofTypeCheck1.types

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

tests/baselines/reference/ES5For-ofTypeCheck2.symbols

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

tests/baselines/reference/ES5For-ofTypeCheck2.types

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

tests/baselines/reference/ES5For-ofTypeCheck3.symbols

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

tests/baselines/reference/ES5For-ofTypeCheck3.types

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

tests/baselines/reference/ES5For-ofTypeCheck4.symbols

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

tests/baselines/reference/ES5For-ofTypeCheck4.types

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

tests/baselines/reference/ES5For-ofTypeCheck5.symbols

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

tests/baselines/reference/ES5For-ofTypeCheck5.types

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

tests/baselines/reference/ES5For-ofTypeCheck6.symbols

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

tests/baselines/reference/ES5For-ofTypeCheck6.types

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

tests/baselines/reference/ES5SymbolType1.symbols

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

tests/baselines/reference/ES5SymbolType1.types

@@ -1,10 +1,10 @@
 === tests/cases/conformance/Symbols/ES5SymbolType1.ts ===
 var s: symbol;
->s : symbol, Symbol(s, Decl(ES5SymbolType1.ts, 0, 3))
+>s : symbol
 
 s.toString();
 >s.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))
+>s.toString : () => string
+>s : symbol
+>toString : () => string
 

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.symbols

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

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types

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

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.symbols

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

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types

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

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols

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

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

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

tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.symbols

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

tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.types

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

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.symbols

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

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

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

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.symbols

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

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

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

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.symbols

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

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types

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

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.symbols

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

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types

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

tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.symbols

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

tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

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

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.symbols

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

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.types

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

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.symbols

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