From 5c8173bd585c79e2fb5fdd10bfe09f6eaf2c0a56 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 14:38:14 -0800 Subject: [PATCH 01/19] Allow typescript to be importable in node. --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index f6391394c6aa1..a52067a3d084e 100644 --- a/package.json +++ b/package.json @@ -25,7 +25,7 @@ "url" : "https://github.com/Microsoft/TypeScript.git" }, "preferGlobal" : true, - "main" : "./bin/tsc.js", + "main" : "./bin/typescriptServices.js", "bin" : { "tsc" : "./bin/tsc" }, From 73ee0382be10c3162f5a42036411228f7fbf3c7e Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Thu, 4 Dec 2014 16:37:12 -0800 Subject: [PATCH 02/19] Use __filename for 'getExecutingFilePath'. --- src/compiler/sys.ts | 5 +++-- src/harness/harness.ts | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts index e58d08589ba60..adcedb02869af 100644 --- a/src/compiler/sys.ts +++ b/src/compiler/sys.ts @@ -25,6 +25,7 @@ declare var require: any; declare var module: any; declare var process: any; declare var global: any; +declare var __filename: string; var sys: System = (function () { @@ -224,10 +225,10 @@ var sys: System = (function () { } }, getExecutingFilePath() { - return process.mainModule.filename; + return __filename; }, getCurrentDirectory() { - return (process).cwd(); + return process.cwd(); }, getMemoryUsage() { if (global.gc) { diff --git a/src/harness/harness.ts b/src/harness/harness.ts index c0d3ddedce325..387f6b6bc22d6 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -25,7 +25,7 @@ // this will work in the browser via browserify var _chai: typeof chai = require('chai'); var assert: typeof _chai.assert = _chai.assert; -declare var __dirname: any; // Node-specific +declare var __dirname: string; // Node-specific var global = Function("return this").call(null); module Utils { From 4deea66c1c7501f4a1b160033b95c5d0dad3cbde Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Fri, 5 Dec 2014 16:33:39 -0800 Subject: [PATCH 03/19] Put 'sys' into the 'ts' module. --- src/compiler/sys.ts | 466 +++++++++++++++++----------------- src/compiler/tsc.ts | 2 +- src/harness/fourslash.ts | 10 +- src/harness/harness.ts | 33 +-- src/harness/projectsRunner.ts | 24 +- src/harness/runner.ts | 2 +- src/harness/rwcRunner.ts | 16 +- 7 files changed, 279 insertions(+), 274 deletions(-) diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts index adcedb02869af..27a8c305c4bc9 100644 --- a/src/compiler/sys.ts +++ b/src/compiler/sys.ts @@ -1,253 +1,255 @@ -interface System { - args: string[]; - newLine: string; - useCaseSensitiveFileNames: boolean; - write(s: string): void; - readFile(fileName: string, encoding?: string): string; - writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void; - watchFile?(fileName: string, callback: (fileName: string) => void): FileWatcher; - resolvePath(path: string): string; - fileExists(path: string): boolean; - directoryExists(path: string): boolean; - createDirectory(directoryName: string): void; - getExecutingFilePath(): string; - getCurrentDirectory(): string; - getMemoryUsage?(): number; - exit(exitCode?: number): void; -} - -interface FileWatcher { - close(): void; -} - -declare var require: any; -declare var module: any; -declare var process: any; -declare var global: any; -declare var __filename: string; - -var sys: System = (function () { - - function getWScriptSystem(): System { - - var fso = new ActiveXObject("Scripting.FileSystemObject"); - - var fileStream = new ActiveXObject("ADODB.Stream"); - fileStream.Type = 2 /*text*/; - - var binaryStream = new ActiveXObject("ADODB.Stream"); - binaryStream.Type = 1 /*binary*/; - - var args: string[] = []; - for (var i = 0; i < WScript.Arguments.length; i++) { - args[i] = WScript.Arguments.Item(i); - } +module ts { + export interface System { + args: string[]; + newLine: string; + useCaseSensitiveFileNames: boolean; + write(s: string): void; + readFile(fileName: string, encoding?: string): string; + writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void; + watchFile? (fileName: string, callback: (fileName: string) => void): FileWatcher; + resolvePath(path: string): string; + fileExists(path: string): boolean; + directoryExists(path: string): boolean; + createDirectory(directoryName: string): void; + getExecutingFilePath(): string; + getCurrentDirectory(): string; + getMemoryUsage? (): number; + exit(exitCode?: number): void; + } + + export interface FileWatcher { + close(): void; + } + + declare var require: any; + declare var module: any; + declare var process: any; + declare var global: any; + declare var __filename: string; + + export var sys: System = (function () { + + function getWScriptSystem(): System { + + var fso = new ActiveXObject("Scripting.FileSystemObject"); - function readFile(fileName: string, encoding?: string): string { - if (!fso.FileExists(fileName)) { - return undefined; + var fileStream = new ActiveXObject("ADODB.Stream"); + fileStream.Type = 2 /*text*/; + + var binaryStream = new ActiveXObject("ADODB.Stream"); + binaryStream.Type = 1 /*binary*/; + + var args: string[] = []; + for (var i = 0; i < WScript.Arguments.length; i++) { + args[i] = WScript.Arguments.Item(i); } - fileStream.Open(); - try { - if (encoding) { - fileStream.Charset = encoding; - fileStream.LoadFromFile(fileName); + + function readFile(fileName: string, encoding?: string): string { + if (!fso.FileExists(fileName)) { + return undefined; } - else { - // Load file and read the first two bytes into a string with no interpretation - fileStream.Charset = "x-ansi"; - fileStream.LoadFromFile(fileName); - var bom = fileStream.ReadText(2) || ""; - // Position must be at 0 before encoding can be changed - fileStream.Position = 0; - // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8 - fileStream.Charset = bom.length >= 2 && (bom.charCodeAt(0) === 0xFF && bom.charCodeAt(1) === 0xFE || bom.charCodeAt(0) === 0xFE && bom.charCodeAt(1) === 0xFF) ? "unicode" : "utf-8"; + fileStream.Open(); + try { + if (encoding) { + fileStream.Charset = encoding; + fileStream.LoadFromFile(fileName); + } + else { + // Load file and read the first two bytes into a string with no interpretation + fileStream.Charset = "x-ansi"; + fileStream.LoadFromFile(fileName); + var bom = fileStream.ReadText(2) || ""; + // Position must be at 0 before encoding can be changed + fileStream.Position = 0; + // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8 + fileStream.Charset = bom.length >= 2 && (bom.charCodeAt(0) === 0xFF && bom.charCodeAt(1) === 0xFE || bom.charCodeAt(0) === 0xFE && bom.charCodeAt(1) === 0xFF) ? "unicode" : "utf-8"; + } + // ReadText method always strips byte order mark from resulting string + return fileStream.ReadText(); + } + catch (e) { + throw e; + } + finally { + fileStream.Close(); } - // ReadText method always strips byte order mark from resulting string - return fileStream.ReadText(); - } - catch (e) { - throw e; - } - finally { - fileStream.Close(); } - } - function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void { - fileStream.Open(); - binaryStream.Open(); - try { - // Write characters in UTF-8 encoding - fileStream.Charset = "utf-8"; - fileStream.WriteText(data); - // If we don't want the BOM, then skip it by setting the starting location to 3 (size of BOM). - // If not, start from position 0, as the BOM will be added automatically when charset==utf8. - if (writeByteOrderMark) { - fileStream.Position = 0; + function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void { + fileStream.Open(); + binaryStream.Open(); + try { + // Write characters in UTF-8 encoding + fileStream.Charset = "utf-8"; + fileStream.WriteText(data); + // If we don't want the BOM, then skip it by setting the starting location to 3 (size of BOM). + // If not, start from position 0, as the BOM will be added automatically when charset==utf8. + if (writeByteOrderMark) { + fileStream.Position = 0; + } + else { + fileStream.Position = 3; + } + fileStream.CopyTo(binaryStream); + binaryStream.SaveToFile(fileName, 2 /*overwrite*/); } - else { - fileStream.Position = 3; + finally { + binaryStream.Close(); + fileStream.Close(); } - fileStream.CopyTo(binaryStream); - binaryStream.SaveToFile(fileName, 2 /*overwrite*/); } - finally { - binaryStream.Close(); - fileStream.Close(); - } - } - return { - args, - newLine: "\r\n", - useCaseSensitiveFileNames: false, - write(s: string): void { - WScript.StdOut.Write(s); - }, - readFile, - writeFile, - resolvePath(path: string): string { - return fso.GetAbsolutePathName(path); - }, - fileExists(path: string): boolean { - return fso.FileExists(path); - }, - directoryExists(path: string) { - return fso.FolderExists(path); - }, - createDirectory(directoryName: string) { - if (!this.directoryExists(directoryName)) { - fso.CreateFolder(directoryName); + return { + args, + newLine: "\r\n", + useCaseSensitiveFileNames: false, + write(s: string): void { + WScript.StdOut.Write(s); + }, + readFile, + writeFile, + resolvePath(path: string): string { + return fso.GetAbsolutePathName(path); + }, + fileExists(path: string): boolean { + return fso.FileExists(path); + }, + directoryExists(path: string) { + return fso.FolderExists(path); + }, + createDirectory(directoryName: string) { + if (!this.directoryExists(directoryName)) { + fso.CreateFolder(directoryName); + } + }, + getExecutingFilePath() { + return WScript.ScriptFullName; + }, + getCurrentDirectory() { + return new ActiveXObject("WScript.Shell").CurrentDirectory; + }, + exit(exitCode?: number): void { + try { + WScript.Quit(exitCode); + } + catch (e) { + } } - }, - getExecutingFilePath() { - return WScript.ScriptFullName; - }, - getCurrentDirectory() { - return new ActiveXObject("WScript.Shell").CurrentDirectory; - }, - exit(exitCode?: number): void { - try { - WScript.Quit(exitCode); + }; + } + function getNodeSystem(): System { + var _fs = require("fs"); + var _path = require("path"); + var _os = require('os'); + + var platform: string = _os.platform(); + // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive + var useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin"; + + function readFile(fileName: string, encoding?: string): string { + if (!_fs.existsSync(fileName)) { + return undefined; } - catch (e) { + var buffer = _fs.readFileSync(fileName); + var len = buffer.length; + if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) { + // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js, + // flip all byte pairs and treat as little endian. + len &= ~1; + for (var i = 0; i < len; i += 2) { + var temp = buffer[i]; + buffer[i] = buffer[i + 1]; + buffer[i + 1] = temp; + } + return buffer.toString("utf16le", 2); } - } - }; - } - function getNodeSystem(): System { - var _fs = require("fs"); - var _path = require("path"); - var _os = require('os'); - - var platform: string = _os.platform(); - // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive - var useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin"; - - function readFile(fileName: string, encoding?: string): string { - if (!_fs.existsSync(fileName)) { - return undefined; - } - var buffer = _fs.readFileSync(fileName); - var len = buffer.length; - if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) { - // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js, - // flip all byte pairs and treat as little endian. - len &= ~1; - for (var i = 0; i < len; i += 2) { - var temp = buffer[i]; - buffer[i] = buffer[i + 1]; - buffer[i + 1] = temp; + if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) { + // Little endian UTF-16 byte order mark detected + return buffer.toString("utf16le", 2); } - return buffer.toString("utf16le", 2); - } - if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) { - // Little endian UTF-16 byte order mark detected - return buffer.toString("utf16le", 2); - } - if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { - // UTF-8 byte order mark detected - return buffer.toString("utf8", 3); + if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { + // UTF-8 byte order mark detected + return buffer.toString("utf8", 3); + } + // Default is UTF-8 with no byte order mark + return buffer.toString("utf8"); } - // Default is UTF-8 with no byte order mark - return buffer.toString("utf8"); - } - function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void { - // If a BOM is required, emit one - if (writeByteOrderMark) { - data = '\uFEFF' + data; - } + function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void { + // If a BOM is required, emit one + if (writeByteOrderMark) { + data = '\uFEFF' + data; + } - _fs.writeFileSync(fileName, data, "utf8"); - } + _fs.writeFileSync(fileName, data, "utf8"); + } - return { - args: process.argv.slice(2), - newLine: _os.EOL, - useCaseSensitiveFileNames: useCaseSensitiveFileNames, - write(s: string): void { - // 1 is a standard descriptor for stdout - _fs.writeSync(1, s); - }, - readFile, - writeFile, - watchFile: (fileName, callback) => { - // watchFile polls a file every 250ms, picking up file notifications. - _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged); - - return { - close() { _fs.unwatchFile(fileName, fileChanged); } - }; - - function fileChanged(curr: any, prev: any) { - if (+curr.mtime <= +prev.mtime) { - return; + return { + args: process.argv.slice(2), + newLine: _os.EOL, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + write(s: string): void { + // 1 is a standard descriptor for stdout + _fs.writeSync(1, s); + }, + readFile, + writeFile, + watchFile: (fileName, callback) => { + // watchFile polls a file every 250ms, picking up file notifications. + _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged); + + return { + close() { _fs.unwatchFile(fileName, fileChanged); } + }; + + function fileChanged(curr: any, prev: any) { + if (+curr.mtime <= +prev.mtime) { + return; + } + + callback(fileName); + }; + }, + resolvePath: function (path: string): string { + return _path.resolve(path); + }, + fileExists(path: string): boolean { + return _fs.existsSync(path); + }, + directoryExists(path: string) { + return _fs.existsSync(path) && _fs.statSync(path).isDirectory(); + }, + createDirectory(directoryName: string) { + if (!this.directoryExists(directoryName)) { + _fs.mkdirSync(directoryName); } - - callback(fileName); - }; - }, - resolvePath: function (path: string): string { - return _path.resolve(path); - }, - fileExists(path: string): boolean { - return _fs.existsSync(path); - }, - directoryExists(path: string) { - return _fs.existsSync(path) && _fs.statSync(path).isDirectory(); - }, - createDirectory(directoryName: string) { - if (!this.directoryExists(directoryName)) { - _fs.mkdirSync(directoryName); - } - }, - getExecutingFilePath() { - return __filename; - }, - getCurrentDirectory() { - return process.cwd(); - }, - getMemoryUsage() { - if (global.gc) { - global.gc(); + }, + getExecutingFilePath() { + return __filename; + }, + getCurrentDirectory() { + return process.cwd(); + }, + getMemoryUsage() { + if (global.gc) { + global.gc(); + } + return process.memoryUsage().heapUsed; + }, + exit(exitCode?: number): void { + process.exit(exitCode); } - return process.memoryUsage().heapUsed; - }, - exit(exitCode?: number): void { - process.exit(exitCode); - } - }; - } - if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") { - return getWScriptSystem(); - } - else if (typeof module !== "undefined" && module.exports) { - return getNodeSystem(); - } - else { - return undefined; // Unsupported host - } -})(); + }; + } + if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") { + return getWScriptSystem(); + } + else if (typeof module !== "undefined" && module.exports) { + return getNodeSystem(); + } + else { + return undefined; // Unsupported host + } + })(); +} \ No newline at end of file diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index fbe596ee0f771..1756f26ab48f4 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -490,4 +490,4 @@ module ts { } } -ts.executeCommandLine(sys.args); +ts.executeCommandLine(ts.sys.args); diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 0114d213398b0..da13735872d68 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -363,7 +363,7 @@ module FourSlash { this.formatCodeOptions = { IndentSize: 4, TabSize: 4, - NewLineCharacter: sys.newLine, + NewLineCharacter: ts.sys.newLine, ConvertTabsToSpaces: true, InsertSpaceAfterCommaDelimiter: true, InsertSpaceAfterSemicolonInForStatements: true, @@ -1747,9 +1747,9 @@ module FourSlash { } function jsonMismatchString() { - return sys.newLine + - "expected: '" + sys.newLine + JSON.stringify(expected, (k,v) => v, 2) + "'" + sys.newLine + - "actual: '" + sys.newLine + JSON.stringify(actual, (k, v) => v, 2) + "'"; + return ts.sys.newLine + + "expected: '" + ts.sys.newLine + JSON.stringify(expected, (k,v) => v, 2) + "'" + ts.sys.newLine + + "actual: '" + ts.sys.newLine + JSON.stringify(actual, (k, v) => v, 2) + "'"; } } @@ -2246,7 +2246,7 @@ module FourSlash { { unitName: fileName, content: content }], (fn, contents) => result = contents, ts.ScriptTarget.Latest, - sys.useCaseSensitiveFileNames); + ts.sys.useCaseSensitiveFileNames); // TODO (drosen): We need to enforce checking on these tests. var program = ts.createProgram([Harness.Compiler.fourslashFilename, fileName], { out: "fourslashTestOutput.js", noResolve: true }, host); var checker = ts.createTypeChecker(program, /*fullTypeCheckMode*/ true); diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 387f6b6bc22d6..ba182e1b24d60 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -22,6 +22,9 @@ /// /// +declare var require: any; +declare var process: any; + // this will work in the browser via browserify var _chai: typeof chai = require('chai'); var assert: typeof _chai.assert = _chai.assert; @@ -41,7 +44,7 @@ module Utils { export function getExecutionEnvironment() { if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") { return ExecutionEnvironment.CScript; - } else if (process && (process).execPath && (process).execPath.indexOf("node") !== -1) { + } else if (process && process.execPath && process.execPath.indexOf("node") !== -1) { return ExecutionEnvironment.Node; } else { return ExecutionEnvironment.Browser; @@ -89,7 +92,7 @@ module Utils { } try { - var content = sys.readFile(Harness.userSpecifiedroot + path); + var content = ts.sys.readFile(Harness.userSpecifiedroot + path); } catch (err) { return undefined; @@ -156,8 +159,8 @@ module Harness { fso = {}; } - export var readFile: typeof IO.readFile = sys.readFile; - export var writeFile: typeof IO.writeFile = sys.writeFile; + export var readFile: typeof IO.readFile = ts.sys.readFile; + export var writeFile: typeof IO.writeFile = ts.sys.writeFile; export var directoryName: typeof IO.directoryName = fso.GetParentFolderName; export var directoryExists: typeof IO.directoryExists = fso.FolderExists; export var fileExists: typeof IO.fileExists = fso.FileExists; @@ -218,8 +221,8 @@ module Harness { fs = pathModule = {}; } - export var readFile: typeof IO.readFile = sys.readFile; - export var writeFile: typeof IO.writeFile = sys.writeFile; + export var readFile: typeof IO.readFile = ts.sys.readFile; + export var writeFile: typeof IO.writeFile = ts.sys.writeFile; export var fileExists: typeof IO.fileExists = fs.existsSync; export var log: typeof IO.log = console.log; @@ -547,7 +550,7 @@ module Harness { export var fourslashSourceFile: ts.SourceFile; export function getCanonicalFileName(fileName: string): string { - return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(); + return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(); } export function createCompilerHost(inputFiles: { unitName: string; content: string; }[], @@ -571,7 +574,7 @@ module Harness { inputFiles.forEach(register); return { - getCurrentDirectory: sys.getCurrentDirectory, + getCurrentDirectory: ts.sys.getCurrentDirectory, getCancellationToken: (): any => undefined, getSourceFile: (fn, languageVersion) => { if (Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(fn))) { @@ -594,7 +597,7 @@ module Harness { writeFile, getCanonicalFileName, useCaseSensitiveFileNames: () => useCaseSensitiveFileNames, - getNewLine: ()=> sys.newLine + getNewLine: ()=> ts.sys.newLine }; } @@ -664,7 +667,7 @@ module Harness { settingsCallback(null); } - var useCaseSensitiveFileNames = sys.useCaseSensitiveFileNames; + var useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames; this.settings.forEach(setting => { switch (setting.flag.toLowerCase()) { // "filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noimplicitany", "noresolve" @@ -742,7 +745,7 @@ module Harness { case 'newline': case 'newlines': - sys.newLine = setting.value; + ts.sys.newLine = setting.value; break; case 'comments': @@ -817,11 +820,11 @@ module Harness { }); this.lastErrors = errors; - var result = new CompilerResult(fileOutputs, errors, program, sys.getCurrentDirectory(), emitResult ? emitResult.sourceMaps : undefined); + var result = new CompilerResult(fileOutputs, errors, program, ts.sys.getCurrentDirectory(), emitResult ? emitResult.sourceMaps : undefined); onComplete(result, checker); // reset what newline means in case the last test changed it - sys.newLine = '\r\n'; + ts.sys.newLine = '\r\n'; return options; } @@ -916,7 +919,7 @@ module Harness { errorOutput += diagnotic.filename + "(" + diagnotic.line + "," + diagnotic.character + "): "; } - errorOutput += diagnotic.category + " TS" + diagnotic.code + ": " + diagnotic.message + sys.newLine; + errorOutput += diagnotic.category + " TS" + diagnotic.code + ": " + diagnotic.message + ts.sys.newLine; }); return errorOutput; @@ -1014,7 +1017,7 @@ module Harness { assert.equal(totalErrorsReported + numLibraryDiagnostics, diagnostics.length, 'total number of errors'); return minimalDiagnosticsToString(diagnostics) + - sys.newLine + sys.newLine + outputLines.join('\r\n'); + ts.sys.newLine + ts.sys.newLine + outputLines.join('\r\n'); } export function collateOutputs(outputFiles: Harness.Compiler.GeneratedFile[], clean?: (s: string) => string) { diff --git a/src/harness/projectsRunner.ts b/src/harness/projectsRunner.ts index f46f9ae369846..9e2432c1da439 100644 --- a/src/harness/projectsRunner.ts +++ b/src/harness/projectsRunner.ts @@ -60,7 +60,7 @@ class ProjectRunner extends RunnerBase { var testCase: ProjectRunnerTestCase; try { - var testFileText = sys.readFile(testCaseFileName); + var testFileText = ts.sys.readFile(testCaseFileName); } catch (e) { assert(false, "Unable to open testcase file: " + testCaseFileName + ": " + e.message); @@ -96,7 +96,7 @@ class ProjectRunner extends RunnerBase { } function cleanProjectUrl(url: string) { - var diskProjectPath = ts.normalizeSlashes(sys.resolvePath(testCase.projectRoot)); + var diskProjectPath = ts.normalizeSlashes(ts.sys.resolvePath(testCase.projectRoot)); var projectRootUrl = "file:///" + diskProjectPath; var normalizedProjectRoot = ts.normalizeSlashes(testCase.projectRoot); diskProjectPath = diskProjectPath.substr(0, diskProjectPath.lastIndexOf(normalizedProjectRoot)); @@ -119,7 +119,7 @@ class ProjectRunner extends RunnerBase { } function getCurrentDirectory() { - return sys.resolvePath(testCase.projectRoot); + return ts.sys.resolvePath(testCase.projectRoot); } function compileProjectFiles(moduleKind: ts.ModuleKind, getInputFiles: ()=> string[], @@ -161,8 +161,8 @@ class ProjectRunner extends RunnerBase { sourceMap: !!testCase.sourceMap, out: testCase.out, outDir: testCase.outDir, - mapRoot: testCase.resolveMapRoot && testCase.mapRoot ? sys.resolvePath(testCase.mapRoot) : testCase.mapRoot, - sourceRoot: testCase.resolveSourceRoot && testCase.sourceRoot ? sys.resolvePath(testCase.sourceRoot) : testCase.sourceRoot, + mapRoot: testCase.resolveMapRoot && testCase.mapRoot ? ts.sys.resolvePath(testCase.mapRoot) : testCase.mapRoot, + sourceRoot: testCase.resolveSourceRoot && testCase.sourceRoot ? ts.sys.resolvePath(testCase.sourceRoot) : testCase.sourceRoot, module: moduleKind, noResolve: testCase.noResolve }; @@ -190,8 +190,8 @@ class ProjectRunner extends RunnerBase { writeFile, getCurrentDirectory, getCanonicalFileName: Harness.Compiler.getCanonicalFileName, - useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames, - getNewLine: () => sys.newLine + useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames, + getNewLine: () => ts.sys.newLine }; } } @@ -213,7 +213,7 @@ class ProjectRunner extends RunnerBase { function getSourceFileText(filename: string): string { try { - var text = sys.readFile(ts.isRootedDiskPath(filename) + var text = ts.sys.readFile(ts.isRootedDiskPath(filename) ? filename : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(filename)); } @@ -260,14 +260,14 @@ class ProjectRunner extends RunnerBase { // Actual writing of file as in tc.ts function ensureDirectoryStructure(directoryname: string) { if (directoryname) { - if (!sys.directoryExists(directoryname)) { + if (!ts.sys.directoryExists(directoryname)) { ensureDirectoryStructure(ts.getDirectoryPath(directoryname)); - sys.createDirectory(directoryname); + ts.sys.createDirectory(directoryname); } } } ensureDirectoryStructure(ts.getDirectoryPath(ts.normalizePath(outputFilePath))); - sys.writeFile(outputFilePath, data, writeByteOrderMark); + ts.sys.writeFile(outputFilePath, data, writeByteOrderMark); outputFiles.push({ emittedFileName: filename, code: data, fileName: diskRelativeName, writeByteOrderMark: writeByteOrderMark }); } @@ -374,7 +374,7 @@ class ProjectRunner extends RunnerBase { it('Baseline of emitted result (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, () => { Harness.Baseline.runBaseline('Baseline of emitted result (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + outputFile.fileName, () => { try { - return sys.readFile(getProjectOutputFolder(outputFile.fileName, compilerResult.moduleKind)); + return ts.sys.readFile(getProjectOutputFolder(outputFile.fileName, compilerResult.moduleKind)); } catch (e) { return undefined; diff --git a/src/harness/runner.ts b/src/harness/runner.ts index da37c02e2244c..24349ada3fd54 100644 --- a/src/harness/runner.ts +++ b/src/harness/runner.ts @@ -94,6 +94,6 @@ if (runners.length === 0) { //runners.push(new GeneratedFourslashRunner()); } -sys.newLine = '\r\n'; +ts.sys.newLine = '\r\n'; runTests(runners); diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts index b8bc2a80a529c..8d22b1da1d8b4 100644 --- a/src/harness/rwcRunner.ts +++ b/src/harness/rwcRunner.ts @@ -6,17 +6,17 @@ module RWC { function runWithIOLog(ioLog: IOLog, fn: () => void) { - var oldSys = sys; + var oldSys = ts.sys; - var wrappedSys = Playback.wrapSystem(sys); + var wrappedSys = Playback.wrapSystem(ts.sys); wrappedSys.startReplayFromData(ioLog); - sys = wrappedSys; + ts.sys = wrappedSys; try { fn(); } finally { wrappedSys.endReplay(); - sys = oldSys; + ts.sys = oldSys; } } @@ -74,7 +74,7 @@ module RWC { } ts.forEach(ioLog.filesRead, fileRead => { - var resolvedPath = ts.normalizeSlashes(sys.resolvePath(fileRead.path)); + var resolvedPath = ts.normalizeSlashes(ts.sys.resolvePath(fileRead.path)); var inInputList = ts.forEach(inputFiles, inputFile=> inputFile.unitName === resolvedPath); if (!inInputList) { // Add the file to other files @@ -92,9 +92,9 @@ module RWC { }); function getHarnessCompilerInputUnit(fileName: string) { - var unitName = ts.normalizeSlashes(sys.resolvePath(fileName)); + var unitName = ts.normalizeSlashes(ts.sys.resolvePath(fileName)); try { - var content = sys.readFile(unitName); + var content = ts.sys.readFile(unitName); } catch (e) { // Leave content undefined. @@ -160,7 +160,7 @@ module RWC { } return Harness.Compiler.minimalDiagnosticsToString(declFileCompilationResult.declResult.errors) + - sys.newLine + sys.newLine + + ts.sys.newLine + ts.sys.newLine + Harness.Compiler.getErrorBaseline(declFileCompilationResult.declInputFiles.concat(declFileCompilationResult.declOtherFiles), declFileCompilationResult.declResult.errors); }, false, baselineOpts); } From 0d9b2c8725ef337dff3efb839e07bf233274d6a3 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sat, 6 Dec 2014 09:10:16 -0800 Subject: [PATCH 04/19] move text defintions to services.ts --- src/services/formatting/references.ts | 1 - src/services/services.ts | 296 +++++++++++++++++++++++++- src/services/text.ts | 296 -------------------------- 3 files changed, 295 insertions(+), 298 deletions(-) delete mode 100644 src/services/text.ts diff --git a/src/services/formatting/references.ts b/src/services/formatting/references.ts index 9f4b7e3743699..3d19b33d82126 100644 --- a/src/services/formatting/references.ts +++ b/src/services/formatting/references.ts @@ -13,7 +13,6 @@ // limitations under the License. // -/// /// /// /// diff --git a/src/services/services.ts b/src/services/services.ts index 980b7ecda3db0..e31d2b42ee579 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4,7 +4,6 @@ /// /// -/// /// /// /// @@ -933,6 +932,301 @@ module ts { dispose(): void; } + export class TextSpan { + private _start: number; + private _length: number; + + /** + * Creates a TextSpan instance beginning with the position Start and having the Length + * specified with length. + */ + constructor(start: number, length: number) { + Debug.assert(start >= 0, "start"); + Debug.assert(length >= 0, "length"); + + this._start = start; + this._length = length; + } + + public toJSON(key: any): any { + return { start: this._start, length: this._length }; + } + + public start(): number { + return this._start; + } + + public length(): number { + return this._length; + } + + public end(): number { + return this._start + this._length; + } + + public isEmpty(): boolean { + return this._length === 0; + } + + /** + * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less + * than End, otherwise false. + * @param position The position to check. + */ + public containsPosition(position: number): boolean { + return position >= this._start && position < this.end(); + } + + /** + * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false. + * @param span The span to check. + */ + public containsTextSpan(span: TextSpan): boolean { + return span._start >= this._start && span.end() <= this.end(); + } + + /** + * Determines whether the given span overlaps this span. Two spans are considered to overlap + * if they have positions in common and neither is empty. Empty spans do not overlap with any + * other span. Returns true if the spans overlap, false otherwise. + * @param span The span to check. + */ + public overlapsWith(span: TextSpan): boolean { + var overlapStart = Math.max(this._start, span._start); + var overlapEnd = Math.min(this.end(), span.end()); + + return overlapStart < overlapEnd; + } + + /** + * Returns the overlap with the given span, or undefined if there is no overlap. + * @param span The span to check. + */ + public overlap(span: TextSpan): TextSpan { + var overlapStart = Math.max(this._start, span._start); + var overlapEnd = Math.min(this.end(), span.end()); + + if (overlapStart < overlapEnd) { + return TextSpan.fromBounds(overlapStart, overlapEnd); + } + + return undefined; + } + + /** + * Determines whether span intersects this span. Two spans are considered to + * intersect if they have positions in common or the end of one span + * coincides with the start of the other span. Returns true if the spans intersect, false otherwise. + * @param The span to check. + */ + public intersectsWithTextSpan(span: TextSpan): boolean { + return span._start <= this.end() && span.end() >= this._start; + } + + public intersectsWith(start: number, length: number): boolean { + var end = start + length; + return start <= this.end() && end >= this._start; + } + + /** + * Determines whether the given position intersects this span. + * A position is considered to intersect if it is between the start and + * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise. + * @param position The position to check. + */ + public intersectsWithPosition(position: number): boolean { + return position <= this.end() && position >= this._start; + } + + /** + * Returns the intersection with the given span, or undefined if there is no intersection. + * @param span The span to check. + */ + public intersection(span: TextSpan): TextSpan { + var intersectStart = Math.max(this._start, span._start); + var intersectEnd = Math.min(this.end(), span.end()); + + if (intersectStart <= intersectEnd) { + return TextSpan.fromBounds(intersectStart, intersectEnd); + } + + return undefined; + } + + /** + * Creates a new TextSpan from the given start and end positions + * as opposed to a position and length. + */ + public static fromBounds(start: number, end: number): TextSpan { + Debug.assert(start >= 0); + Debug.assert(end - start >= 0); + return new TextSpan(start, end - start); + } + } + + export class TextChangeRange { + public static unchanged = new TextChangeRange(new TextSpan(0, 0), 0); + + private _span: TextSpan; + private _newLength: number; + + /** + * Initializes a new instance of TextChangeRange. + */ + constructor(span: TextSpan, newLength: number) { + Debug.assert(newLength >= 0, "newLength"); + + this._span = span; + this._newLength = newLength; + } + + /** + * The span of text before the edit which is being changed + */ + public span(): TextSpan { + return this._span; + } + + /** + * Width of the span after the edit. A 0 here would represent a delete + */ + public newLength(): number { + return this._newLength; + } + + public newSpan(): TextSpan { + return new TextSpan(this.span().start(), this.newLength()); + } + + public isUnchanged(): boolean { + return this.span().isEmpty() && this.newLength() === 0; + } + + /** + * Called to merge all the changes that occurred across several versions of a script snapshot + * into a single change. i.e. if a user keeps making successive edits to a script we will + * have a text change from V1 to V2, V2 to V3, ..., Vn. + * + * This function will then merge those changes into a single change range valid between V1 and + * Vn. + */ + public static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange { + if (changes.length === 0) { + return TextChangeRange.unchanged; + } + + if (changes.length === 1) { + return changes[0]; + } + + // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd } + // as it makes things much easier to reason about. + var change0 = changes[0]; + + var oldStartN = change0.span().start(); + var oldEndN = change0.span().end(); + var newEndN = oldStartN + change0.newLength(); + + for (var i = 1; i < changes.length; i++) { + var nextChange = changes[i]; + + // Consider the following case: + // i.e. two edits. The first represents the text change range { { 10, 50 }, 30 }. i.e. The span starting + // at 10, with length 50 is reduced to length 30. The second represents the text change range { { 30, 30 }, 40 }. + // i.e. the span starting at 30 with length 30 is increased to length 40. + // + // 0 10 20 30 40 50 60 70 80 90 100 + // ------------------------------------------------------------------------------------------------------- + // | / + // | /---- + // T1 | /---- + // | /---- + // | /---- + // ------------------------------------------------------------------------------------------------------- + // | \ + // | \ + // T2 | \ + // | \ + // | \ + // ------------------------------------------------------------------------------------------------------- + // + // Merging these turns out to not be too difficult. First, determining the new start of the change is trivial + // it's just the min of the old and new starts. i.e.: + // + // 0 10 20 30 40 50 60 70 80 90 100 + // ------------------------------------------------------------*------------------------------------------ + // | / + // | /---- + // T1 | /---- + // | /---- + // | /---- + // ----------------------------------------$-------------------$------------------------------------------ + // . | \ + // . | \ + // T2 . | \ + // . | \ + // . | \ + // ----------------------------------------------------------------------*-------------------------------- + // + // (Note the dots represent the newly inferrred start. + // Determining the new and old end is also pretty simple. Basically it boils down to paying attention to the + // absolute positions at the asterixes, and the relative change between the dollar signs. Basically, we see + // which if the two $'s precedes the other, and we move that one forward until they line up. in this case that + // means: + // + // 0 10 20 30 40 50 60 70 80 90 100 + // --------------------------------------------------------------------------------*---------------------- + // | / + // | /---- + // T1 | /---- + // | /---- + // | /---- + // ------------------------------------------------------------$------------------------------------------ + // . | \ + // . | \ + // T2 . | \ + // . | \ + // . | \ + // ----------------------------------------------------------------------*-------------------------------- + // + // In other words (in this case), we're recognizing that the second edit happened after where the first edit + // ended with a delta of 20 characters (60 - 40). Thus, if we go back in time to where the first edit started + // that's the same as if we started at char 80 instead of 60. + // + // As it so happens, the same logic applies if the second edit precedes the first edit. In that case rahter + // than pusing the first edit forward to match the second, we'll push the second edit forward to match the + // first. + // + // In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange + // semantics: { { start: 10, length: 70 }, newLength: 60 } + // + // The math then works out as follows. + // If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the + // final result like so: + // + // { + // oldStart3: Min(oldStart1, oldStart2), + // oldEnd3 : Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)), + // newEnd3 : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)) + // } + + var oldStart1 = oldStartN; + var oldEnd1 = oldEndN; + var newEnd1 = newEndN; + + var oldStart2 = nextChange.span().start(); + var oldEnd2 = nextChange.span().end(); + var newEnd2 = oldStart2 + nextChange.newLength(); + + oldStartN = Math.min(oldStart1, oldStart2); + oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); + newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); + } + + return new TextChangeRange(TextSpan.fromBounds(oldStartN, oldEndN), /*newLength: */newEndN - oldStartN); + } + } + export interface ClassifiedSpan { textSpan: TextSpan; classificationType: string; // ClassificationTypeNames diff --git a/src/services/text.ts b/src/services/text.ts deleted file mode 100644 index fd768785dea68..0000000000000 --- a/src/services/text.ts +++ /dev/null @@ -1,296 +0,0 @@ -module ts { - export class TextSpan { - private _start: number; - private _length: number; - - /** - * Creates a TextSpan instance beginning with the position Start and having the Length - * specified with length. - */ - constructor(start: number, length: number) { - Debug.assert(start >= 0, "start"); - Debug.assert(length >= 0, "length"); - - this._start = start; - this._length = length; - } - - public toJSON(key: any): any { - return { start: this._start, length: this._length }; - } - - public start(): number { - return this._start; - } - - public length(): number { - return this._length; - } - - public end(): number { - return this._start + this._length; - } - - public isEmpty(): boolean { - return this._length === 0; - } - - /** - * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less - * than End, otherwise false. - * @param position The position to check. - */ - public containsPosition(position: number): boolean { - return position >= this._start && position < this.end(); - } - - /** - * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false. - * @param span The span to check. - */ - public containsTextSpan(span: TextSpan): boolean { - return span._start >= this._start && span.end() <= this.end(); - } - - /** - * Determines whether the given span overlaps this span. Two spans are considered to overlap - * if they have positions in common and neither is empty. Empty spans do not overlap with any - * other span. Returns true if the spans overlap, false otherwise. - * @param span The span to check. - */ - public overlapsWith(span: TextSpan): boolean { - var overlapStart = Math.max(this._start, span._start); - var overlapEnd = Math.min(this.end(), span.end()); - - return overlapStart < overlapEnd; - } - - /** - * Returns the overlap with the given span, or undefined if there is no overlap. - * @param span The span to check. - */ - public overlap(span: TextSpan): TextSpan { - var overlapStart = Math.max(this._start, span._start); - var overlapEnd = Math.min(this.end(), span.end()); - - if (overlapStart < overlapEnd) { - return TextSpan.fromBounds(overlapStart, overlapEnd); - } - - return undefined; - } - - /** - * Determines whether span intersects this span. Two spans are considered to - * intersect if they have positions in common or the end of one span - * coincides with the start of the other span. Returns true if the spans intersect, false otherwise. - * @param The span to check. - */ - public intersectsWithTextSpan(span: TextSpan): boolean { - return span._start <= this.end() && span.end() >= this._start; - } - - public intersectsWith(start: number, length: number): boolean { - var end = start + length; - return start <= this.end() && end >= this._start; - } - - /** - * Determines whether the given position intersects this span. - * A position is considered to intersect if it is between the start and - * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise. - * @param position The position to check. - */ - public intersectsWithPosition(position: number): boolean { - return position <= this.end() && position >= this._start; - } - - /** - * Returns the intersection with the given span, or undefined if there is no intersection. - * @param span The span to check. - */ - public intersection(span: TextSpan): TextSpan { - var intersectStart = Math.max(this._start, span._start); - var intersectEnd = Math.min(this.end(), span.end()); - - if (intersectStart <= intersectEnd) { - return TextSpan.fromBounds(intersectStart, intersectEnd); - } - - return undefined; - } - - /** - * Creates a new TextSpan from the given start and end positions - * as opposed to a position and length. - */ - public static fromBounds(start: number, end: number): TextSpan { - Debug.assert(start >= 0); - Debug.assert(end - start >= 0); - return new TextSpan(start, end - start); - } - } - - export class TextChangeRange { - public static unchanged = new TextChangeRange(new TextSpan(0, 0), 0); - - private _span: TextSpan; - private _newLength: number; - - /** - * Initializes a new instance of TextChangeRange. - */ - constructor(span: TextSpan, newLength: number) { - Debug.assert(newLength >= 0, "newLength"); - - this._span = span; - this._newLength = newLength; - } - - /** - * The span of text before the edit which is being changed - */ - public span(): TextSpan { - return this._span; - } - - /** - * Width of the span after the edit. A 0 here would represent a delete - */ - public newLength(): number { - return this._newLength; - } - - public newSpan(): TextSpan { - return new TextSpan(this.span().start(), this.newLength()); - } - - public isUnchanged(): boolean { - return this.span().isEmpty() && this.newLength() === 0; - } - - /** - * Called to merge all the changes that occurred across several versions of a script snapshot - * into a single change. i.e. if a user keeps making successive edits to a script we will - * have a text change from V1 to V2, V2 to V3, ..., Vn. - * - * This function will then merge those changes into a single change range valid between V1 and - * Vn. - */ - public static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange { - if (changes.length === 0) { - return TextChangeRange.unchanged; - } - - if (changes.length === 1) { - return changes[0]; - } - - // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd } - // as it makes things much easier to reason about. - var change0 = changes[0]; - - var oldStartN = change0.span().start(); - var oldEndN = change0.span().end(); - var newEndN = oldStartN + change0.newLength(); - - for (var i = 1; i < changes.length; i++) { - var nextChange = changes[i]; - - // Consider the following case: - // i.e. two edits. The first represents the text change range { { 10, 50 }, 30 }. i.e. The span starting - // at 10, with length 50 is reduced to length 30. The second represents the text change range { { 30, 30 }, 40 }. - // i.e. the span starting at 30 with length 30 is increased to length 40. - // - // 0 10 20 30 40 50 60 70 80 90 100 - // ------------------------------------------------------------------------------------------------------- - // | / - // | /---- - // T1 | /---- - // | /---- - // | /---- - // ------------------------------------------------------------------------------------------------------- - // | \ - // | \ - // T2 | \ - // | \ - // | \ - // ------------------------------------------------------------------------------------------------------- - // - // Merging these turns out to not be too difficult. First, determining the new start of the change is trivial - // it's just the min of the old and new starts. i.e.: - // - // 0 10 20 30 40 50 60 70 80 90 100 - // ------------------------------------------------------------*------------------------------------------ - // | / - // | /---- - // T1 | /---- - // | /---- - // | /---- - // ----------------------------------------$-------------------$------------------------------------------ - // . | \ - // . | \ - // T2 . | \ - // . | \ - // . | \ - // ----------------------------------------------------------------------*-------------------------------- - // - // (Note the dots represent the newly inferrred start. - // Determining the new and old end is also pretty simple. Basically it boils down to paying attention to the - // absolute positions at the asterixes, and the relative change between the dollar signs. Basically, we see - // which if the two $'s precedes the other, and we move that one forward until they line up. in this case that - // means: - // - // 0 10 20 30 40 50 60 70 80 90 100 - // --------------------------------------------------------------------------------*---------------------- - // | / - // | /---- - // T1 | /---- - // | /---- - // | /---- - // ------------------------------------------------------------$------------------------------------------ - // . | \ - // . | \ - // T2 . | \ - // . | \ - // . | \ - // ----------------------------------------------------------------------*-------------------------------- - // - // In other words (in this case), we're recognizing that the second edit happened after where the first edit - // ended with a delta of 20 characters (60 - 40). Thus, if we go back in time to where the first edit started - // that's the same as if we started at char 80 instead of 60. - // - // As it so happens, the same logic applies if the second edit precedes the first edit. In that case rahter - // than pusing the first edit forward to match the second, we'll push the second edit forward to match the - // first. - // - // In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange - // semantics: { { start: 10, length: 70 }, newLength: 60 } - // - // The math then works out as follows. - // If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the - // final result like so: - // - // { - // oldStart3: Min(oldStart1, oldStart2), - // oldEnd3 : Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)), - // newEnd3 : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)) - // } - - var oldStart1 = oldStartN; - var oldEnd1 = oldEndN; - var newEnd1 = newEndN; - - var oldStart2 = nextChange.span().start(); - var oldEnd2 = nextChange.span().end(); - var newEnd2 = oldStart2 + nextChange.newLength(); - - oldStartN = Math.min(oldStart1, oldStart2); - oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); - newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); - } - - return new TextChangeRange(TextSpan.fromBounds(oldStartN, oldEndN), /*newLength: */newEndN - oldStartN); - } - } -} \ No newline at end of file From 523c1795b812dbd868c89446e9396a5f8081a81d Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 7 Dec 2014 20:55:37 -0800 Subject: [PATCH 05/19] use ts.System for tests --- src/harness/loggedIO.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts index c6305c50c10dd..c6d15c34a84dd 100644 --- a/src/harness/loggedIO.ts +++ b/src/harness/loggedIO.ts @@ -91,7 +91,7 @@ module Playback { return run; } - export interface PlaybackSystem extends System, PlaybackControl { } + export interface PlaybackSystem extends ts.System, PlaybackControl { } function createEmptyLog(): IOLog { return { @@ -221,7 +221,7 @@ module Playback { //console.log("Swallowed write operation during replay: " + name); } - export function wrapSystem(underlying: System): PlaybackSystem { + export function wrapSystem(underlying: ts.System): PlaybackSystem { var wrapper: PlaybackSystem = {}; initWrapper(wrapper, underlying); From fc950ed930dd3154230c74a40d3233c19de3a28b Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 7 Dec 2014 21:22:22 -0800 Subject: [PATCH 06/19] Move Map to types to ensure it is visible in definition files --- src/compiler/core.ts | 4 ---- src/compiler/types.ts | 3 +++ 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 8dfc0d59ea9f7..e61602c1c4506 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -15,10 +15,6 @@ module ts { True = -1 } - export interface Map { - [index: string]: T; - } - export const enum Comparison { LessThan = -1, EqualTo = 0, diff --git a/src/compiler/types.ts b/src/compiler/types.ts index c2d57876e6a76..a08d2cb7a1292 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -1,6 +1,9 @@ /// module ts { + export interface Map { + [index: string]: T; + } export interface TextRange { pos: number; From cf340efe010c74be84305a4f5eddc478271583e9 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 7 Dec 2014 15:55:40 -0800 Subject: [PATCH 07/19] remove unused file --- src/services/findReferenceHelpers.ts | 152 --------------------------- 1 file changed, 152 deletions(-) delete mode 100644 src/services/findReferenceHelpers.ts diff --git a/src/services/findReferenceHelpers.ts b/src/services/findReferenceHelpers.ts deleted file mode 100644 index 68131a41115cd..0000000000000 --- a/src/services/findReferenceHelpers.ts +++ /dev/null @@ -1,152 +0,0 @@ -// Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0. -// See LICENSE.txt in the project root for complete license information. - -/// - -module TypeScript.Services { - export class FindReferenceHelpers { - public static compareSymbolsForLexicalIdentity(firstSymbol: TypeScript.PullSymbol, secondSymbol: TypeScript.PullSymbol): boolean { - // Unwrap modules so that we're always referring to the variable. - if (!firstSymbol.isAlias() && firstSymbol.isContainer()) { - var containerForFirstSymbol = (firstSymbol); - if (containerForFirstSymbol.getInstanceSymbol()) { - firstSymbol = containerForFirstSymbol.getInstanceSymbol(); - } - } - - if (!secondSymbol.isAlias() && secondSymbol.isContainer()) { - var containerForSecondSymbol = (secondSymbol); - if (containerForSecondSymbol.getInstanceSymbol()) { - secondSymbol = containerForSecondSymbol.getInstanceSymbol(); - } - } - - if (firstSymbol.kind === secondSymbol.kind) { - if (firstSymbol === secondSymbol) { - return true; - } - - // If we have two variables and they have the same name and the same parent, then - // they are the same symbol. - if (firstSymbol.kind === TypeScript.PullElementKind.Variable && - firstSymbol.name === secondSymbol.name && - firstSymbol.getDeclarations() && firstSymbol.getDeclarations().length >= 1 && - secondSymbol.getDeclarations() && secondSymbol.getDeclarations().length >= 1) { - - var firstSymbolDecl = firstSymbol.getDeclarations()[0]; - var secondSymbolDecl = secondSymbol.getDeclarations()[0]; - - return firstSymbolDecl.getParentDecl() === secondSymbolDecl.getParentDecl(); - } - - // If we have two properties that belong to an object literal, then we need ot see - // if they came from teh same object literal ast. - if (firstSymbol.kind === TypeScript.PullElementKind.Property && - firstSymbol.name === secondSymbol.name && - firstSymbol.getDeclarations() && firstSymbol.getDeclarations().length >= 1 && - secondSymbol.getDeclarations() && secondSymbol.getDeclarations().length >= 1) { - - var firstSymbolDecl = firstSymbol.getDeclarations()[0]; - var secondSymbolDecl = secondSymbol.getDeclarations()[0]; - - var firstParentDecl = firstSymbolDecl.getParentDecl(); - var secondParentDecl = secondSymbolDecl.getParentDecl(); - - if (firstParentDecl.kind === TypeScript.PullElementKind.ObjectLiteral && - secondParentDecl.kind === TypeScript.PullElementKind.ObjectLiteral) { - - return firstParentDecl.ast() === secondParentDecl.ast(); - } - } - - // check if we are dealing with the implementation of interface method or a method override - if (firstSymbol.name === secondSymbol.name) { - // at this point firstSymbol.kind === secondSymbol.kind so we can pick any of those - switch (firstSymbol.kind) { - case PullElementKind.Property: - case PullElementKind.Method: - case PullElementKind.GetAccessor: - case PullElementKind.SetAccessor: - // these kinds can only be defined in types - var t1 = firstSymbol.getContainer(); - var t2 = secondSymbol.getContainer(); - t1._resolveDeclaredSymbol(); - t2._resolveDeclaredSymbol(); - - return t1.hasBase(t2) || t2.hasBase(t1); - break; - } - } - - return false; - } - else { - switch (firstSymbol.kind) { - case TypeScript.PullElementKind.Class: { - return this.checkSymbolsForDeclarationEquality(firstSymbol, secondSymbol); - } - case TypeScript.PullElementKind.Property: { - if (firstSymbol.isAccessor()) { - var getterSymbol = (firstSymbol).getGetter(); - var setterSymbol = (firstSymbol).getSetter(); - - if (getterSymbol && getterSymbol === secondSymbol) { - return true; - } - - if (setterSymbol && setterSymbol === secondSymbol) { - return true; - } - } - return false; - } - case TypeScript.PullElementKind.Function: { - if (secondSymbol.isAccessor()) { - var getterSymbol = (secondSymbol).getGetter(); - var setterSymbol = (secondSymbol).getSetter(); - - if (getterSymbol && getterSymbol === firstSymbol) { - return true; - } - - if (setterSymbol && setterSymbol === firstSymbol) { - return true; - } - } - return false; - } - case TypeScript.PullElementKind.ConstructorMethod: { - return this.checkSymbolsForDeclarationEquality(firstSymbol, secondSymbol); - } - } - } - - return firstSymbol === secondSymbol; - } - - private static checkSymbolsForDeclarationEquality(firstSymbol: TypeScript.PullSymbol, secondSymbol: TypeScript.PullSymbol): boolean { - var firstSymbolDeclarations: TypeScript.PullDecl[] = firstSymbol.getDeclarations(); - var secondSymbolDeclarations: TypeScript.PullDecl[] = secondSymbol.getDeclarations(); - for (var i = 0, iLen = firstSymbolDeclarations.length; i < iLen; i++) { - for (var j = 0, jLen = secondSymbolDeclarations.length; j < jLen; j++) { - if (this.declarationsAreSameOrParents(firstSymbolDeclarations[i], secondSymbolDeclarations[j])) { - return true; - } - } - } - return false; - } - - private static declarationsAreSameOrParents(firstDecl: TypeScript.PullDecl, secondDecl: TypeScript.PullDecl): boolean { - var firstParent: TypeScript.PullDecl = firstDecl.getParentDecl(); - var secondParent: TypeScript.PullDecl = secondDecl.getParentDecl(); - if (firstDecl === secondDecl || - firstDecl === secondParent || - firstParent === secondDecl || - firstParent === secondParent) { - return true; - } - return false; - } - } -} \ No newline at end of file From f90e725aa0d6dc5c621ea1bd31fa23337f37dd30 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 7 Dec 2014 16:26:08 -0800 Subject: [PATCH 08/19] move formatting.ts and smartIndernter.ts into formatting folder to match thier namespace --- src/services/{ => formatting}/formatting.ts | 59 +++++++++++++++++-- src/services/formatting/formattingScanner.ts | 2 +- .../{ => formatting}/smartIndenter.ts | 2 +- src/services/services.ts | 6 +- 4 files changed, 60 insertions(+), 9 deletions(-) rename src/services/{ => formatting}/formatting.ts (93%) rename src/services/{ => formatting}/smartIndenter.ts (97%) diff --git a/src/services/formatting.ts b/src/services/formatting/formatting.ts similarity index 93% rename from src/services/formatting.ts rename to src/services/formatting/formatting.ts index ad18df41317f2..107251aabda74 100644 --- a/src/services/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -1,7 +1,6 @@ -/// -/// -/// -/// +/// +/// +/// module ts.formatting { @@ -983,4 +982,56 @@ module ts.formatting { return SyntaxKind.Unknown; } + + var internedTabsIndentation: string[]; + var internedSpacesIndentation: string[]; + + export function getIndentationString(indentation: number, options: FormatCodeOptions): string { + if (!options.ConvertTabsToSpaces) { + var tabs = Math.floor(indentation / options.TabSize); + var spaces = indentation - tabs * options.TabSize; + + var tabString: string; + if (!internedTabsIndentation) { + internedTabsIndentation = []; + } + + if (internedTabsIndentation[tabs] === undefined) { + internedTabsIndentation[tabs] = tabString = repeat('\t', tabs); + } + else { + tabString = internedTabsIndentation[tabs]; + } + + return spaces ? tabString + repeat(" ", spaces) : tabString; + } + else { + var spacesString: string; + var quotient = Math.floor(indentation / options.IndentSize); + var remainder = indentation % options.IndentSize; + if (!internedSpacesIndentation) { + internedSpacesIndentation = []; + } + + if (internedSpacesIndentation[quotient] === undefined) { + spacesString = repeat(" ", options.IndentSize * quotient); + internedSpacesIndentation[quotient] = spacesString; + } + else { + spacesString = internedSpacesIndentation[quotient]; + } + + + return remainder ? spacesString + repeat(" ", remainder) : spacesString; + } + + function repeat(value: string, count: number): string { + var s = ""; + for (var i = 0; i < count; ++i) { + s += value; + } + + return s; + } + } } \ No newline at end of file diff --git a/src/services/formatting/formattingScanner.ts b/src/services/formatting/formattingScanner.ts index 710881bf80bda..7ddfecc17f2a5 100644 --- a/src/services/formatting/formattingScanner.ts +++ b/src/services/formatting/formattingScanner.ts @@ -1,4 +1,4 @@ -/// +/// /// module ts.formatting { diff --git a/src/services/smartIndenter.ts b/src/services/formatting/smartIndenter.ts similarity index 97% rename from src/services/smartIndenter.ts rename to src/services/formatting/smartIndenter.ts index e93cb5616a9c5..8da1ef0c93b6a 100644 --- a/src/services/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -1,4 +1,4 @@ -/// +/// module ts.formatting { export module SmartIndenter { diff --git a/src/services/services.ts b/src/services/services.ts index e31d2b42ee579..f1744c8d4ab85 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4,13 +4,13 @@ /// /// +/// /// /// -/// /// /// -/// -/// +/// +/// module ts { export interface Node { From 6da0b57d1913684f2fbcc58e12653920d5278182 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 14:49:59 -0800 Subject: [PATCH 09/19] Removed tokenSpan.ts. --- src/services/formatting/formatting.ts | 1 + src/services/formatting/references.ts | 3 +-- src/services/formatting/tokenSpan.ts | 24 ------------------------ 3 files changed, 2 insertions(+), 26 deletions(-) delete mode 100644 src/services/formatting/tokenSpan.ts diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index 107251aabda74..22f90a0cdee08 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -1,5 +1,6 @@ /// /// +/// /// module ts.formatting { diff --git a/src/services/formatting/references.ts b/src/services/formatting/references.ts index 3d19b33d82126..b421424a61be4 100644 --- a/src/services/formatting/references.ts +++ b/src/services/formatting/references.ts @@ -24,5 +24,4 @@ /// /// /// -/// -/// \ No newline at end of file +/// \ No newline at end of file diff --git a/src/services/formatting/tokenSpan.ts b/src/services/formatting/tokenSpan.ts deleted file mode 100644 index 1d8173a8227f4..0000000000000 --- a/src/services/formatting/tokenSpan.ts +++ /dev/null @@ -1,24 +0,0 @@ -// -// Copyright (c) Microsoft Corporation. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -/// - -module ts.formatting { - export class TokenSpan extends TextSpan { - constructor(public kind: SyntaxKind, start: number, length: number) { - super(start, length); - } - } -} \ No newline at end of file From 1fab80f3d98517aa22e1f257e2bcc509145f1ccd Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 7 Dec 2014 21:23:03 -0800 Subject: [PATCH 10/19] move OutliningSpan definitions to services to ensure it is visible in definitions file --- src/services/outliningElementsCollector.ts | 16 ---------------- src/services/services.ts | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts index 83eef2f437824..5af69cd3626a2 100644 --- a/src/services/outliningElementsCollector.ts +++ b/src/services/outliningElementsCollector.ts @@ -14,22 +14,6 @@ // module ts { - - export interface OutliningSpan { - /** - * @param textSpan The span of the document to actually collapse. - * @param hintSpan The span of the document to display when the user hovers over the - * collapsed span. - * @param bannerText The text to display in the editor for the collapsed region. - * @param autoCollapse Whether or not this region should be automatically collapsed when - * the 'Collapse to Definitions' command is invoked. - */ - textSpan: TextSpan; - hintSpan: TextSpan; - bannerText: string; - autoCollapse: boolean; - } - export module OutliningElementsCollector { export function collectElements(sourceFile: SourceFile): OutliningSpan[] { var elements: OutliningSpan[] = []; diff --git a/src/services/services.ts b/src/services/services.ts index f1744c8d4ab85..31a9e7c638bd9 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1409,6 +1409,23 @@ module ts { documentation: SymbolDisplayPart[]; } + export interface OutliningSpan { + /** The span of the document to actually collapse. */ + textSpan: TextSpan; + + /** The span of the document to display when the user hovers over the collapsed span. */ + hintSpan: TextSpan; + + /** The text to display in the editor for the collapsed region. */ + bannerText: string; + + /** + * Whether or not this region should be automatically collapsed when + * the 'Collapse to Definitions' command is invoked. + */ + autoCollapse: boolean; + } + export interface EmitOutput { outputFiles: OutputFile[]; emitOutputStatus: EmitReturnStatus; From 520979d09489ef64348ed34f5b01dbddad36cbd0 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 14:58:08 -0800 Subject: [PATCH 11/19] Make getLocalizedDiagnosticMessages and getCancellationToken optional --- src/harness/harness.ts | 1 - src/services/services.ts | 8 ++++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/harness/harness.ts b/src/harness/harness.ts index ba182e1b24d60..e813b18b457b3 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -575,7 +575,6 @@ module Harness { return { getCurrentDirectory: ts.sys.getCurrentDirectory, - getCancellationToken: (): any => undefined, getSourceFile: (fn, languageVersion) => { if (Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(fn))) { return filemap[getCanonicalFileName(fn)]; diff --git a/src/services/services.ts b/src/services/services.ts index 31a9e7c638bd9..ff917028eee6d 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -875,8 +875,8 @@ module ts { getScriptVersion(fileName: string): string; getScriptIsOpen(fileName: string): boolean; getScriptSnapshot(fileName: string): IScriptSnapshot; - getLocalizedDiagnosticMessages(): any; - getCancellationToken(): CancellationToken; + getLocalizedDiagnosticMessages?(): any; + getCancellationToken?(): CancellationToken; getCurrentDirectory(): string; getDefaultLibFilename(options: CompilerOptions): string; } @@ -2395,12 +2395,12 @@ module ts { var useCaseSensitivefilenames = false; var sourceFilesByName: Map = {}; var documentRegistry = documentRegistry; - var cancellationToken = new CancellationTokenObject(host.getCancellationToken()); + var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken()); var activeCompletionSession: CompletionSession; // The current active completion session, used to get the completion entry details var writer: (filename: string, data: string, writeByteOrderMark: boolean) => void = undefined; // Check if the localized messages json is set, otherwise query the host for it - if (!localizedDiagnosticMessages) { + if (!localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) { localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages(); } From f690f054fc7e67cc59438031bce2419148fd752d Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Mon, 8 Dec 2014 13:00:46 -0800 Subject: [PATCH 12/19] Remove unused parameter to getCompletionsAtPosition Conflicts: tests/baselines/reference/APISample_node_compile.js tests/baselines/reference/APISample_node_compile.types tests/baselines/reference/APISample_standalone_compile.js tests/baselines/reference/APISample_standalone_compile.types --- src/harness/fourslash.ts | 6 +++--- src/services/services.ts | 6 +++--- src/services/shims.ts | 8 ++++---- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index da13735872d68..e523def8be204 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -750,11 +750,11 @@ module FourSlash { } private getMemberListAtCaret() { - return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition, true); + return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition); } private getCompletionListAtCaret() { - return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition, false); + return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition); } private getCompletionEntryDetails(entryName: string) { @@ -1364,7 +1364,7 @@ module FourSlash { this.languageService.getSignatureHelpItems(this.activeFile.fileName, offset); } else if (prevChar === ' ' && /A-Za-z_/.test(ch)) { /* Completions */ - this.languageService.getCompletionsAtPosition(this.activeFile.fileName, offset, false); + this.languageService.getCompletionsAtPosition(this.activeFile.fileName, offset); } if (i % errorCadence === 0) { diff --git a/src/services/services.ts b/src/services/services.ts index ff917028eee6d..76f4fece035c3 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -895,7 +895,7 @@ module ts { getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; - getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; + getCompletionsAtPosition(fileName: string, position: number): CompletionInfo; getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; @@ -2666,7 +2666,7 @@ module ts { }; } - function getCompletionsAtPosition(filename: string, position: number, isMemberCompletion: boolean) { + function getCompletionsAtPosition(filename: string, position: number) { synchronizeHostData(); filename = normalizeSlashes(filename); @@ -2741,7 +2741,7 @@ module ts { if (isRightOfDot) { // Right of dot member completion list var symbols: Symbol[] = []; - isMemberCompletion = true; + var isMemberCompletion = true; if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression) { var symbol = typeInfoResolver.getSymbolAtLocation(node); diff --git a/src/services/shims.ts b/src/services/shims.ts index 5556743830fc5..127e6c3120985 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -88,7 +88,7 @@ module ts { getSyntacticClassifications(fileName: string, start: number, length: number): string; - getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): string; + getCompletionsAtPosition(fileName: string, position: number): string; getCompletionEntryDetails(fileName: string, position: number, entryName: string): string; getQuickInfoAtPosition(fileName: string, position: number): string; @@ -686,11 +686,11 @@ module ts { * to provide at the given source position and providing a member completion * list if requested. */ - public getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean) { + public getCompletionsAtPosition(fileName: string, position: number) { return this.forwardJSONCall( - "getCompletionsAtPosition('" + fileName + "', " + position + ", " + isMemberCompletion + ")", + "getCompletionsAtPosition('" + fileName + "', " + position + ")", () => { - var completion = this.languageService.getCompletionsAtPosition(fileName, position, isMemberCompletion); + var completion = this.languageService.getCompletionsAtPosition(fileName, position); return completion; }); } From e2baddd7161d433bb1ab23329a57b12efda69fd1 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Mon, 8 Dec 2014 17:42:08 -0800 Subject: [PATCH 13/19] Explicit default target for fourslash tests in the harness. --- src/harness/fourslash.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index e523def8be204..ac64e4c906e5a 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -2248,7 +2248,7 @@ module FourSlash { ts.ScriptTarget.Latest, ts.sys.useCaseSensitiveFileNames); // TODO (drosen): We need to enforce checking on these tests. - var program = ts.createProgram([Harness.Compiler.fourslashFilename, fileName], { out: "fourslashTestOutput.js", noResolve: true }, host); + var program = ts.createProgram([Harness.Compiler.fourslashFilename, fileName], { out: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host); var checker = ts.createTypeChecker(program, /*fullTypeCheckMode*/ true); var errors = program.getDiagnostics().concat(checker.getDiagnostics()); From 7c6d731b62d4276cd858299a797d66f25ee3890a Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 16:42:41 -0800 Subject: [PATCH 14/19] Moved non-exposed functions to utilities; fix up emitted .d.ts in Jakefile. --- Jakefile | 111 ++++-- src/compiler/checker.ts | 54 +-- src/compiler/parser.ts | 676 +----------------------------------- src/compiler/utilities.ts | 707 ++++++++++++++++++++++++++++++++++++++ src/services/services.ts | 179 +--------- src/services/utilities.ts | 178 +++++++++- 6 files changed, 991 insertions(+), 914 deletions(-) create mode 100644 src/compiler/utilities.ts diff --git a/Jakefile b/Jakefile index 16330305b6a08..7c58800c79dc6 100644 --- a/Jakefile +++ b/Jakefile @@ -35,6 +35,7 @@ var compilerSources = [ "types.ts", "scanner.ts", "parser.ts", + "utilities.ts", "binder.ts", "checker.ts", "emitter.ts", @@ -47,26 +48,53 @@ var compilerSources = [ var servicesSources = [ "core.ts", + "sys.ts", "types.ts", "scanner.ts", "parser.ts", + "utilities.ts", "binder.ts", "checker.ts", - "emitter.ts" + "emitter.ts", + "diagnosticInformationMap.generated.ts" ].map(function (f) { return path.join(compilerDirectory, f); }).concat([ "breakpoints.ts", + "navigationBar.ts", + "outliningElementsCollector.ts", "services.ts", "shims.ts", "signatureHelp.ts", "utilities.ts", - "navigationBar.ts", - "outliningElementsCollector.ts" + "formatting/formatting.ts", + "formatting/formattingContext.ts", + "formatting/formattingRequestKind.ts", + "formatting/formattingScanner.ts", + "formatting/references.ts", + "formatting/rule.ts", + "formatting/ruleAction.ts", + "formatting/ruleDescriptor.ts", + "formatting/ruleFlag.ts", + "formatting/ruleOperation.ts", + "formatting/ruleOperationContext.ts", + "formatting/rules.ts", + "formatting/rulesMap.ts", + "formatting/rulesProvider.ts", + "formatting/smartIndenter.ts", + "formatting/tokenRange.ts" ].map(function (f) { return path.join(servicesDirectory, f); })); +var definitionsRoots = [ + "compiler/types.d.ts", + "compiler/scanner.d.ts", + "compiler/parser.d.ts", + "compiler/checker.d.ts", + "services/services.d.ts", +]; + var harnessSources = [ "harness.ts", "sourceMapRecorder.ts", @@ -148,25 +176,48 @@ var compilerFilename = "tsc.js"; * @param prefixes: a list of files to prepend to the target file * @param useBuiltCompiler: true to use the built compiler, false to use the LKG * @param noOutFile: true to compile without using --out + * @param generateDeclarations: true to compile using --declaration + * @param outDir: true to compile using --outDir + * @param keepComments: false to compile using --removeComments + * @param callback: a function to execute after the compilation process ends */ -function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOutFile, generateDeclarations, callback) { +function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOutFile, generateDeclarations, outDir, keepComments, noResolve, callback) { file(outFile, prereqs, function() { var dir = useBuiltCompiler ? builtLocalDirectory : LKGDirectory; - var options = "-removeComments --module commonjs -noImplicitAny "; + var options = "--module commonjs -noImplicitAny"; + + if (!keepComments) { + options += " -removeComments"; + } + if (generateDeclarations) { - options += "--declaration "; + options += " --declaration"; } if (useDebugMode) { - options += "--preserveConstEnums "; + options += " --preserveConstEnums"; + } + + if (outDir) { + options += " --outDir " + outDir; + } + + if (!noOutFile) { + options += " --out " + outFile; + } + + if(noResolve) { + options += " --noResolve"; } - var cmd = host + " " + dir + compilerFilename + " " + options + " "; - cmd = cmd + sources.join(" ") + (!noOutFile ? " -out " + outFile : ""); if (useDebugMode) { - cmd = cmd + " -sourcemap -mapRoot file:///" + path.resolve(path.dirname(outFile)); + options += " -sourcemap -mapRoot file:///" + path.resolve(path.dirname(outFile)); } + + var cmd = host + " " + dir + compilerFilename + " " + options + " "; + cmd = cmd + sources.join(" "); console.log(cmd + "\n"); + var ex = jake.createExec([cmd]); // Add listeners for output and error ex.addListener("stdout", function(output) { @@ -259,24 +310,38 @@ var tscFile = path.join(builtLocalDirectory, compilerFilename); compileFile(tscFile, compilerSources, [builtLocalDirectory, copyright].concat(compilerSources), [copyright], /*useBuiltCompiler:*/ false); var servicesFile = path.join(builtLocalDirectory, "typescriptServices.js"); -var servicesDefinitionsFile = path.join(builtLocalDirectory, "typescriptServices.d.ts"); +compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].concat(servicesSources), [copyright], /*useBuiltCompiler*/ true); -compileFile(servicesFile, - servicesSources, - [builtLocalDirectory, copyright].concat(servicesSources), - [copyright], +var nodeDefinitionsFile = path.join(builtLocalDirectory, "typescript.d.ts"); +var standaloneDefinitionsFile = path.join(builtLocalDirectory, "typescriptServices.d.ts"); +var tempDirPath = path.join(builtLocalDirectory, "temptempdir"); +compileFile(nodeDefinitionsFile, servicesSources,[builtLocalDirectory, copyright].concat(servicesSources), + /*prefixes*/ undefined, /*useBuiltCompiler*/ true, - /*noOutFile*/ false, + /*noOutFile*/ true, /*generateDeclarations*/ true, - /*callback*/ fixDeclarationFile); - -function fixDeclarationFile() { - fs.appendFileSync(servicesDefinitionsFile, os.EOL + "export = ts;") -} + /*outDir*/ tempDirPath, + /*keepComments*/ true, + /*noResolve*/ true, + /*callback*/ function () { + concatenateFiles(standaloneDefinitionsFile, definitionsRoots.map(function (f) { + return path.join(tempDirPath, f); + })); + prependFile(copyright, standaloneDefinitionsFile); + + // Create the node definition file by replacing 'ts' module with '"typescript"' as a module. + jake.cpR(standaloneDefinitionsFile, nodeDefinitionsFile, {silent: true}); + var definitionFileContents = fs.readFileSync(nodeDefinitionsFile).toString(); + definitionFileContents = definitionFileContents.replace(/declare module ts/g, 'declare module "typescript"'); + fs.writeFileSync(nodeDefinitionsFile, definitionFileContents); + + // Delete the temp dir + jake.rmRf(tempDirPath, {silent: true}); + }); // Local target to build the compiler and services desc("Builds the full compiler and services"); -task("local", ["generate-diagnostics", "lib", tscFile, servicesFile]); +task("local", ["generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile]); // Local target to build the compiler and services desc("Sets release mode flag"); @@ -327,7 +392,7 @@ task("generate-spec", [specMd]) // Makes a new LKG. This target does not build anything, but errors if not all the outputs are present in the built/local directory desc("Makes a new LKG out of the built js files"); task("LKG", ["clean", "release", "local"].concat(libraryTargets), function() { - var expectedFiles = [tscFile, servicesFile, servicesDefinitionsFile].concat(libraryTargets); + var expectedFiles = [tscFile, servicesFile, nodeDefinitionsFile, standaloneDefinitionsFile].concat(libraryTargets); var missingFiles = expectedFiles.filter(function (f) { return !fs.existsSync(f); }); diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6d913f7360cb9..ec39831525560 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4,57 +4,12 @@ /// /// /// +/// module ts { var nextSymbolId = 1; var nextNodeId = 1; - var nextMergeId = 1; - - export function getDeclarationOfKind(symbol: Symbol, kind: SyntaxKind): Declaration { - var declarations = symbol.declarations; - for (var i = 0; i < declarations.length; i++) { - var declaration = declarations[i]; - if (declaration.kind === kind) { - return declaration; - } - } - - return undefined; - } - - export interface StringSymbolWriter extends SymbolWriter { - string(): string; - } - - // Pool writers to avoid needing to allocate them for every symbol we write. - var stringWriters: StringSymbolWriter[] = []; - export function getSingleLineStringWriter(): StringSymbolWriter { - if (stringWriters.length == 0) { - var str = ""; - - var writeText: (text: string) => void = text => str += text; - return { - string: () => str, - writeKeyword: writeText, - writeOperator: writeText, - writePunctuation: writeText, - writeSpace: writeText, - writeStringLiteral: writeText, - writeParameter: writeText, - writeSymbol: writeText, - - // Completely ignore indentation for string writers. And map newlines to - // a single space. - writeLine: () => str += " ", - increaseIndent: () => { }, - decreaseIndent: () => { }, - clear: () => str = "", - trackSymbol: () => { } - }; - } - - return stringWriters.pop(); - } + var nextMergeId = 1; /// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics. /// If fullTypeCheck === true, then the typechecker should do every possible check to produce all errors @@ -1019,11 +974,6 @@ module ts { }; } - function releaseStringWriter(writer: StringSymbolWriter) { - writer.clear() - stringWriters.push(writer); - } - function writeKeyword(writer: SymbolWriter, kind: SyntaxKind) { writer.writeKeyword(tokenToString(kind)); } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index deb2eb17fc8db..5c0d15359855b 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -1,41 +1,11 @@ /// /// /// +/// module ts { var nodeConstructors = new Array Node>(SyntaxKind.Count); - export function getFullWidth(node: Node) { - return node.end - node.pos; - } - - function hasFlag(val: number, flag: number): boolean { - return (val & flag) !== 0; - } - - // Returns true if this node contains a parse error anywhere underneath it. - export function containsParseError(node: Node): boolean { - if (!hasFlag(node.parserContextFlags, ParserContextFlags.HasPropagatedChildContainsErrorFlag)) { - // A node is considered to contain a parse error if: - // a) the parser explicitly marked that it had an error - // b) any of it's children reported that it had an error. - var val = hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError) || - forEachChild(node, containsParseError); - - // If so, mark ourselves accordingly. - if (val) { - node.parserContextFlags |= ParserContextFlags.ContainsError; - } - - // Also mark that we've propogated the child information to this node. This way we can - // always consult the bit directly on this node without needing to check its children - // again. - node.parserContextFlags |= ParserContextFlags.HasPropagatedChildContainsErrorFlag; - } - - return hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError); - } - export function getNodeConstructor(kind: SyntaxKind): new () => Node { return nodeConstructors[kind] || (nodeConstructors[kind] = objectAllocator.getNodeConstructor(kind)); } @@ -54,181 +24,6 @@ module ts { amdModuleName: string; } - export function getSourceFileOfNode(node: Node): SourceFile { - while (node && node.kind !== SyntaxKind.SourceFile) node = node.parent; - return node; - } - - // This is a useful function for debugging purposes. - export function nodePosToString(node: Node): string { - var file = getSourceFileOfNode(node); - var loc = file.getLineAndCharacterFromPosition(node.pos); - return file.filename + "(" + loc.line + "," + loc.character + ")"; - } - - export function getStartPosOfNode(node: Node): number { - return node.pos; - } - - export function isMissingNode(node: Node) { - return node.pos === node.end && node.kind !== SyntaxKind.EndOfFileToken; - } - - export function getTokenPosOfNode(node: Node, sourceFile?: SourceFile): number { - // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't* - // want to skip trivia because this will launch us forward to the next token. - if (isMissingNode(node)) { - return node.pos; - } - - return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos); - } - - export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node): string { - if (isMissingNode(node)) { - return ""; - } - - var text = sourceFile.text; - return text.substring(skipTrivia(text, node.pos), node.end); - } - - export function getTextOfNodeFromSourceText(sourceText: string, node: Node): string { - if (isMissingNode(node)) { - return ""; - } - - return sourceText.substring(skipTrivia(sourceText, node.pos), node.end); - } - - export function getTextOfNode(node: Node): string { - return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node); - } - - // Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' - export function escapeIdentifier(identifier: string): string { - return identifier.length >= 2 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ ? "_" + identifier : identifier; - } - - // Remove extra underscore from escaped identifier - export function unescapeIdentifier(identifier: string): string { - return identifier.length >= 3 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ && identifier.charCodeAt(2) === CharacterCodes._ ? identifier.substr(1) : identifier; - } - - // Return display name of an identifier - // Computed property names will just be emitted as "[]", where is the source - // text of the expression in the computed property. - export function declarationNameToString(name: DeclarationName) { - return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); - } - - export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic { - node = getErrorSpanForNode(node); - var file = getSourceFileOfNode(node); - - var start = getFullWidth(node) === 0 ? node.pos : skipTrivia(file.text, node.pos); - var length = node.end - start; - - return createFileDiagnostic(file, start, length, message, arg0, arg1, arg2); - } - - export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain, newLine: string): Diagnostic { - node = getErrorSpanForNode(node); - var file = getSourceFileOfNode(node); - var start = skipTrivia(file.text, node.pos); - var length = node.end - start; - return flattenDiagnosticChain(file, start, length, messageChain, newLine); - } - - export function getErrorSpanForNode(node: Node): Node { - var errorSpan: Node; - switch (node.kind) { - // This list is a work in progress. Add missing node kinds to improve their error - // spans. - case SyntaxKind.VariableDeclaration: - case SyntaxKind.ClassDeclaration: - case SyntaxKind.InterfaceDeclaration: - case SyntaxKind.ModuleDeclaration: - case SyntaxKind.EnumDeclaration: - case SyntaxKind.EnumMember: - errorSpan = (node).name; - break; - } - - // We now have the ideal error span, but it may be a node that is optional and absent - // (e.g. the name of a function expression), in which case errorSpan will be undefined. - // Alternatively, it might be required and missing (e.g. the name of a module), in which - // case its pos will equal its end (length 0). In either of these cases, we should fall - // back to the original node that the error was issued on. - return errorSpan && errorSpan.pos < errorSpan.end ? errorSpan : node; - } - - export function isExternalModule(file: SourceFile): boolean { - return file.externalModuleIndicator !== undefined; - } - - export function isDeclarationFile(file: SourceFile): boolean { - return (file.flags & NodeFlags.DeclarationFile) !== 0; - } - - export function isConstEnumDeclaration(node: Node): boolean { - return node.kind === SyntaxKind.EnumDeclaration && isConst(node); - } - - export function isConst(node: Node): boolean { - return !!(node.flags & NodeFlags.Const); - } - - export function isLet(node: Node): boolean { - return !!(node.flags & NodeFlags.Let); - } - - export function isPrologueDirective(node: Node): boolean { - return node.kind === SyntaxKind.ExpressionStatement && (node).expression.kind === SyntaxKind.StringLiteral; - } - - function isEvalOrArgumentsIdentifier(node: Node): boolean { - return node.kind === SyntaxKind.Identifier && - (node).text && - ((node).text === "eval" || (node).text === "arguments"); - } - - /// Should be called only on prologue directives (isPrologueDirective(node) should be true) - function isUseStrictPrologueDirective(node: Node): boolean { - Debug.assert(isPrologueDirective(node)); - return ((node).expression).text === "use strict"; - } - - export function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile) { - sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node); - - // If parameter/type parameter, the prev token trailing comments are part of this node too - if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) { - // e.g. (/** blah */ a, /** blah */ b); - return concatenate(getTrailingCommentRanges(sourceFileOfNode.text, node.pos), - // e.g.: ( - // /** blah */ a, - // /** blah */ b); - getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); - } - else { - return getLeadingCommentRanges(sourceFileOfNode.text, node.pos); - } - } - - export function getJsDocComments(node: Node, sourceFileOfNode: SourceFile) { - return filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), isJsDocComment); - - function isJsDocComment(comment: CommentRange) { - // True if the comment starts with '/**' but not if it is '/**/' - return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk && - sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk && - sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== CharacterCodes.slash; - } - } - - export var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/ - // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise, // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns @@ -473,401 +268,6 @@ module ts { } } - // Warning: This has the same semantics as the forEach family of functions, - // in that traversal terminates in the event that 'visitor' supplies a truthy value. - export function forEachReturnStatement(body: Block, visitor: (stmt: ReturnStatement) => T): T { - - return traverse(body); - - function traverse(node: Node): T { - switch (node.kind) { - case SyntaxKind.ReturnStatement: - return visitor(node); - case SyntaxKind.Block: - case SyntaxKind.IfStatement: - case SyntaxKind.DoStatement: - case SyntaxKind.WhileStatement: - case SyntaxKind.ForStatement: - case SyntaxKind.ForInStatement: - case SyntaxKind.WithStatement: - case SyntaxKind.SwitchStatement: - case SyntaxKind.CaseClause: - case SyntaxKind.DefaultClause: - case SyntaxKind.LabeledStatement: - case SyntaxKind.TryStatement: - case SyntaxKind.TryBlock: - case SyntaxKind.CatchClause: - case SyntaxKind.FinallyBlock: - return forEachChild(node, traverse); - } - } - } - - export function isAnyFunction(node: Node): boolean { - if (node) { - switch (node.kind) { - case SyntaxKind.FunctionExpression: - case SyntaxKind.FunctionDeclaration: - case SyntaxKind.ArrowFunction: - case SyntaxKind.Method: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.Constructor: - return true; - } - } - - return false; - } - - export function isFunctionBlock(node: Node) { - return node !== undefined && node.kind === SyntaxKind.Block && isAnyFunction(node.parent); - } - - export function isObjectLiteralMethod(node: Node) { - return node !== undefined && node.kind === SyntaxKind.Method && node.parent.kind === SyntaxKind.ObjectLiteralExpression; - } - - export function getContainingFunction(node: Node): FunctionLikeDeclaration { - while (true) { - node = node.parent; - if (!node || isAnyFunction(node)) { - return node; - } - } - } - - export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node { - while (true) { - node = node.parent; - if (!node) { - return undefined; - } - switch (node.kind) { - case SyntaxKind.ArrowFunction: - if (!includeArrowFunctions) { - continue; - } - // Fall through - case SyntaxKind.FunctionDeclaration: - case SyntaxKind.FunctionExpression: - case SyntaxKind.ModuleDeclaration: - case SyntaxKind.Property: - case SyntaxKind.Method: - case SyntaxKind.Constructor: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.EnumDeclaration: - case SyntaxKind.SourceFile: - return node; - } - } - } - - export function getSuperContainer(node: Node): Node { - while (true) { - node = node.parent; - if (!node) { - return undefined; - } - switch (node.kind) { - case SyntaxKind.Property: - case SyntaxKind.Method: - case SyntaxKind.Constructor: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - return node; - } - } - } - - export function getInvokedExpression(node: CallLikeExpression): Expression { - if (node.kind === SyntaxKind.TaggedTemplateExpression) { - return (node).tag; - } - - // Will either be a CallExpression or NewExpression. - return (node).expression; - } - - export function isExpression(node: Node): boolean { - switch (node.kind) { - case SyntaxKind.ThisKeyword: - case SyntaxKind.SuperKeyword: - case SyntaxKind.NullKeyword: - case SyntaxKind.TrueKeyword: - case SyntaxKind.FalseKeyword: - case SyntaxKind.RegularExpressionLiteral: - case SyntaxKind.ArrayLiteralExpression: - case SyntaxKind.ObjectLiteralExpression: - case SyntaxKind.PropertyAccessExpression: - case SyntaxKind.ElementAccessExpression: - case SyntaxKind.CallExpression: - case SyntaxKind.NewExpression: - case SyntaxKind.TaggedTemplateExpression: - case SyntaxKind.TypeAssertionExpression: - case SyntaxKind.ParenthesizedExpression: - case SyntaxKind.FunctionExpression: - case SyntaxKind.ArrowFunction: - case SyntaxKind.VoidExpression: - case SyntaxKind.DeleteExpression: - case SyntaxKind.TypeOfExpression: - case SyntaxKind.PrefixUnaryExpression: - case SyntaxKind.PostfixUnaryExpression: - case SyntaxKind.BinaryExpression: - case SyntaxKind.ConditionalExpression: - case SyntaxKind.TemplateExpression: - case SyntaxKind.NoSubstitutionTemplateLiteral: - case SyntaxKind.OmittedExpression: - return true; - case SyntaxKind.QualifiedName: - while (node.parent.kind === SyntaxKind.QualifiedName) { - node = node.parent; - } - - return node.parent.kind === SyntaxKind.TypeQuery; - case SyntaxKind.Identifier: - if (node.parent.kind === SyntaxKind.TypeQuery) { - return true; - } - // fall through - case SyntaxKind.NumericLiteral: - case SyntaxKind.StringLiteral: - var parent = node.parent; - switch (parent.kind) { - case SyntaxKind.VariableDeclaration: - case SyntaxKind.Parameter: - case SyntaxKind.Property: - case SyntaxKind.EnumMember: - case SyntaxKind.PropertyAssignment: - return (parent).initializer === node; - case SyntaxKind.ExpressionStatement: - case SyntaxKind.IfStatement: - case SyntaxKind.DoStatement: - case SyntaxKind.WhileStatement: - case SyntaxKind.ReturnStatement: - case SyntaxKind.WithStatement: - case SyntaxKind.SwitchStatement: - case SyntaxKind.CaseClause: - case SyntaxKind.ThrowStatement: - case SyntaxKind.SwitchStatement: - return (parent).expression === node; - case SyntaxKind.ForStatement: - return (parent).initializer === node || - (parent).condition === node || - (parent).iterator === node; - case SyntaxKind.ForInStatement: - return (parent).variable === node || - (parent).expression === node; - case SyntaxKind.TypeAssertionExpression: - return node === (parent).expression; - case SyntaxKind.TemplateSpan: - return node === (parent).expression; - default: - if (isExpression(parent)) { - return true; - } - } - } - return false; - } - - export function isExternalModuleImportDeclaration(node: Node) { - return node.kind === SyntaxKind.ImportDeclaration && (node).moduleReference.kind === SyntaxKind.ExternalModuleReference; - } - - export function getExternalModuleImportDeclarationExpression(node: Node) { - Debug.assert(isExternalModuleImportDeclaration(node)); - return ((node).moduleReference).expression; - } - - export function isInternalModuleImportDeclaration(node: Node) { - return node.kind === SyntaxKind.ImportDeclaration && (node).moduleReference.kind !== SyntaxKind.ExternalModuleReference; - } - - export function hasDotDotDotToken(node: Node) { - return node && node.kind === SyntaxKind.Parameter && (node).dotDotDotToken !== undefined; - } - - export function hasQuestionToken(node: Node) { - if (node) { - switch (node.kind) { - case SyntaxKind.Parameter: - return (node).questionToken !== undefined; - case SyntaxKind.Method: - return (node).questionToken !== undefined; - case SyntaxKind.ShorthandPropertyAssignment: - case SyntaxKind.PropertyAssignment: - case SyntaxKind.Property: - return (node).questionToken !== undefined; - } - } - - return false; - } - - export function hasRestParameters(s: SignatureDeclaration): boolean { - return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined; - } - - export function isLiteralKind(kind: SyntaxKind): boolean { - return SyntaxKind.FirstLiteralToken <= kind && kind <= SyntaxKind.LastLiteralToken; - } - - export function isTextualLiteralKind(kind: SyntaxKind): boolean { - return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; - } - - export function isTemplateLiteralKind(kind: SyntaxKind): boolean { - return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken; - } - - export function isInAmbientContext(node: Node): boolean { - while (node) { - if (node.flags & (NodeFlags.Ambient | NodeFlags.DeclarationFile)) return true; - node = node.parent; - } - return false; - } - - export function isDeclaration(node: Node): boolean { - switch (node.kind) { - case SyntaxKind.TypeParameter: - case SyntaxKind.Parameter: - case SyntaxKind.VariableDeclaration: - case SyntaxKind.Property: - case SyntaxKind.PropertyAssignment: - case SyntaxKind.ShorthandPropertyAssignment: - case SyntaxKind.EnumMember: - case SyntaxKind.Method: - case SyntaxKind.FunctionDeclaration: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.Constructor: - case SyntaxKind.ClassDeclaration: - case SyntaxKind.InterfaceDeclaration: - case SyntaxKind.TypeAliasDeclaration: - case SyntaxKind.EnumDeclaration: - case SyntaxKind.ModuleDeclaration: - case SyntaxKind.ImportDeclaration: - return true; - } - return false; - } - - export function isStatement(n: Node): boolean { - switch(n.kind) { - case SyntaxKind.BreakStatement: - case SyntaxKind.ContinueStatement: - case SyntaxKind.DebuggerStatement: - case SyntaxKind.DoStatement: - case SyntaxKind.ExpressionStatement: - case SyntaxKind.EmptyStatement: - case SyntaxKind.ForInStatement: - case SyntaxKind.ForStatement: - case SyntaxKind.IfStatement: - case SyntaxKind.LabeledStatement: - case SyntaxKind.ReturnStatement: - case SyntaxKind.SwitchStatement: - case SyntaxKind.ThrowKeyword: - case SyntaxKind.TryStatement: - case SyntaxKind.VariableStatement: - case SyntaxKind.WhileStatement: - case SyntaxKind.WithStatement: - case SyntaxKind.ExportAssignment: - return true; - default: - return false; - } - } - - // True if the given identifier, string literal, or number literal is the name of a declaration node - export function isDeclarationOrFunctionExpressionOrCatchVariableName(name: Node): boolean { - if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) { - return false; - } - - var parent = name.parent; - if (isDeclaration(parent) || parent.kind === SyntaxKind.FunctionExpression) { - return (parent).name === name; - } - - if (parent.kind === SyntaxKind.CatchClause) { - return (parent).name === name; - } - - return false; - } - - export function getClassBaseTypeNode(node: ClassDeclaration) { - var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword); - return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; - } - - export function getClassImplementedTypeNodes(node: ClassDeclaration) { - var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword); - return heritageClause ? heritageClause.types : undefined; - } - - export function getInterfaceBaseTypeNodes(node: InterfaceDeclaration) { - var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword); - return heritageClause ? heritageClause.types : undefined; - } - - export function getHeritageClause(clauses: NodeArray, kind: SyntaxKind) { - if (clauses) { - for (var i = 0, n = clauses.length; i < n; i++) { - if (clauses[i].token === kind) { - return clauses[i]; - } - } - } - - return undefined; - } - - export function tryResolveScriptReference(program: Program, sourceFile: SourceFile, reference: FileReference) { - if (!program.getCompilerOptions().noResolve) { - var referenceFileName = isRootedDiskPath(reference.filename) ? reference.filename : combinePaths(getDirectoryPath(sourceFile.filename), reference.filename); - referenceFileName = getNormalizedAbsolutePath(referenceFileName, program.getCompilerHost().getCurrentDirectory()); - return program.getSourceFile(referenceFileName); - } - } - - export function getAncestor(node: Node, kind: SyntaxKind): Node { - switch (kind) { - // special-cases that can be come first - case SyntaxKind.ClassDeclaration: - while (node) { - switch (node.kind) { - case SyntaxKind.ClassDeclaration: - return node; - case SyntaxKind.EnumDeclaration: - case SyntaxKind.InterfaceDeclaration: - case SyntaxKind.TypeAliasDeclaration: - case SyntaxKind.ModuleDeclaration: - case SyntaxKind.ImportDeclaration: - // early exit cases - declarations cannot be nested in classes - return undefined; - default: - node = node.parent; - continue; - } - } - break; - default: - while (node) { - if (node.kind === kind) { - return node; - } - node = node.parent; - } - break; - } - - return undefined; - } - const enum ParsingContext { SourceElements, // Elements in source file ModuleElements, // Elements in module declaration @@ -919,68 +319,6 @@ module ts { } }; - export interface ReferencePathMatchResult { - fileReference?: FileReference - diagnosticMessage?: DiagnosticMessage - isNoDefaultLib?: boolean - } - - export function getFileReferenceFromReferencePath(comment: string, commentRange: CommentRange): ReferencePathMatchResult { - var simpleReferenceRegEx = /^\/\/\/\s*/gim; - if (simpleReferenceRegEx.exec(comment)) { - if (isNoDefaultLibRegEx.exec(comment)) { - return { - isNoDefaultLib: true - } - } - else { - var matchResult = fullTripleSlashReferencePathRegEx.exec(comment); - if (matchResult) { - var start = commentRange.pos; - var end = commentRange.end; - return { - fileReference: { - pos: start, - end: end, - filename: matchResult[3] - }, - isNoDefaultLib: false - }; - } - else { - return { - diagnosticMessage: Diagnostics.Invalid_reference_directive_syntax, - isNoDefaultLib: false - }; - } - } - } - return undefined; - } - - export function isKeyword(token: SyntaxKind): boolean { - return SyntaxKind.FirstKeyword <= token && token <= SyntaxKind.LastKeyword; - } - - export function isTrivia(token: SyntaxKind) { - return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken; - } - - export function isModifier(token: SyntaxKind): boolean { - switch (token) { - case SyntaxKind.PublicKeyword: - case SyntaxKind.PrivateKeyword: - case SyntaxKind.ProtectedKeyword: - case SyntaxKind.StaticKeyword: - case SyntaxKind.ExportKeyword: - case SyntaxKind.DeclareKeyword: - case SyntaxKind.ConstKeyword: - return true; - } - return false; - } - function modifierToFlag(token: SyntaxKind): NodeFlags { switch (token) { case SyntaxKind.StaticKeyword: return NodeFlags.Static; @@ -994,6 +332,18 @@ module ts { return 0; } + function isEvalOrArgumentsIdentifier(node: Node): boolean { + return node.kind === SyntaxKind.Identifier && + (node).text && + ((node).text === "eval" || (node).text === "arguments"); + } + + /// Should be called only on prologue directives (isPrologueDirective(node) should be true) + function isUseStrictPrologueDirective(node: Node): boolean { + Debug.assert(isPrologueDirective(node)); + return ((node).expression).text === "use strict"; + } + export function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen: boolean = false): SourceFile { var token: SyntaxKind; var parsingContext: ParsingContext; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts new file mode 100644 index 0000000000000..c3e067b7e752e --- /dev/null +++ b/src/compiler/utilities.ts @@ -0,0 +1,707 @@ +/// + +module ts { + export interface ReferencePathMatchResult { + fileReference?: FileReference + diagnosticMessage?: DiagnosticMessage + isNoDefaultLib?: boolean + } + + export function getDeclarationOfKind(symbol: Symbol, kind: SyntaxKind): Declaration { + var declarations = symbol.declarations; + for (var i = 0; i < declarations.length; i++) { + var declaration = declarations[i]; + if (declaration.kind === kind) { + return declaration; + } + } + + return undefined; + } + + export interface StringSymbolWriter extends SymbolWriter { + string(): string; + } + + // Pool writers to avoid needing to allocate them for every symbol we write. + var stringWriters: StringSymbolWriter[] = []; + export function getSingleLineStringWriter(): StringSymbolWriter { + if (stringWriters.length == 0) { + var str = ""; + + var writeText: (text: string) => void = text => str += text; + return { + string: () => str, + writeKeyword: writeText, + writeOperator: writeText, + writePunctuation: writeText, + writeSpace: writeText, + writeStringLiteral: writeText, + writeParameter: writeText, + writeSymbol: writeText, + + // Completely ignore indentation for string writers. And map newlines to + // a single space. + writeLine: () => str += " ", + increaseIndent: () => { }, + decreaseIndent: () => { }, + clear: () => str = "", + trackSymbol: () => { } + }; + } + + return stringWriters.pop(); + } + + export function releaseStringWriter(writer: StringSymbolWriter) { + writer.clear() + stringWriters.push(writer); + } + + export function getFullWidth(node: Node) { + return node.end - node.pos; + } + + export function hasFlag(val: number, flag: number): boolean { + return (val & flag) !== 0; + } + + // Returns true if this node contains a parse error anywhere underneath it. + export function containsParseError(node: Node): boolean { + if (!hasFlag(node.parserContextFlags, ParserContextFlags.HasPropagatedChildContainsErrorFlag)) { + // A node is considered to contain a parse error if: + // a) the parser explicitly marked that it had an error + // b) any of it's children reported that it had an error. + var val = hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError) || + forEachChild(node, containsParseError); + + // If so, mark ourselves accordingly. + if (val) { + node.parserContextFlags |= ParserContextFlags.ContainsError; + } + + // Also mark that we've propogated the child information to this node. This way we can + // always consult the bit directly on this node without needing to check its children + // again. + node.parserContextFlags |= ParserContextFlags.HasPropagatedChildContainsErrorFlag; + } + + return hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError); + } + + export function getSourceFileOfNode(node: Node): SourceFile { + while (node && node.kind !== SyntaxKind.SourceFile) node = node.parent; + return node; + } + + // This is a useful function for debugging purposes. + export function nodePosToString(node: Node): string { + var file = getSourceFileOfNode(node); + var loc = file.getLineAndCharacterFromPosition(node.pos); + return file.filename + "(" + loc.line + "," + loc.character + ")"; + } + + export function getStartPosOfNode(node: Node): number { + return node.pos; + } + + export function isMissingNode(node: Node) { + return node.pos === node.end && node.kind !== SyntaxKind.EndOfFileToken; + } + + export function getTokenPosOfNode(node: Node, sourceFile?: SourceFile): number { + // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't* + // want to skip trivia because this will launch us forward to the next token. + if (isMissingNode(node)) { + return node.pos; + } + + return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos); + } + + export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node): string { + if (isMissingNode(node)) { + return ""; + } + + var text = sourceFile.text; + return text.substring(skipTrivia(text, node.pos), node.end); + } + + export function getTextOfNodeFromSourceText(sourceText: string, node: Node): string { + if (isMissingNode(node)) { + return ""; + } + + return sourceText.substring(skipTrivia(sourceText, node.pos), node.end); + } + + export function getTextOfNode(node: Node): string { + return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node); + } + + // Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' + export function escapeIdentifier(identifier: string): string { + return identifier.length >= 2 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ ? "_" + identifier : identifier; + } + + // Remove extra underscore from escaped identifier + export function unescapeIdentifier(identifier: string): string { + return identifier.length >= 3 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ && identifier.charCodeAt(2) === CharacterCodes._ ? identifier.substr(1) : identifier; + } + + // Return display name of an identifier + // Computed property names will just be emitted as "[]", where is the source + // text of the expression in the computed property. + export function declarationNameToString(name: DeclarationName) { + return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); + } + + export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic { + node = getErrorSpanForNode(node); + var file = getSourceFileOfNode(node); + + var start = getFullWidth(node) === 0 ? node.pos : skipTrivia(file.text, node.pos); + var length = node.end - start; + + return createFileDiagnostic(file, start, length, message, arg0, arg1, arg2); + } + + export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain, newLine: string): Diagnostic { + node = getErrorSpanForNode(node); + var file = getSourceFileOfNode(node); + var start = skipTrivia(file.text, node.pos); + var length = node.end - start; + return flattenDiagnosticChain(file, start, length, messageChain, newLine); + } + + export function getErrorSpanForNode(node: Node): Node { + var errorSpan: Node; + switch (node.kind) { + // This list is a work in progress. Add missing node kinds to improve their error + // spans. + case SyntaxKind.VariableDeclaration: + case SyntaxKind.ClassDeclaration: + case SyntaxKind.InterfaceDeclaration: + case SyntaxKind.ModuleDeclaration: + case SyntaxKind.EnumDeclaration: + case SyntaxKind.EnumMember: + errorSpan = (node).name; + break; + } + + // We now have the ideal error span, but it may be a node that is optional and absent + // (e.g. the name of a function expression), in which case errorSpan will be undefined. + // Alternatively, it might be required and missing (e.g. the name of a module), in which + // case its pos will equal its end (length 0). In either of these cases, we should fall + // back to the original node that the error was issued on. + return errorSpan && errorSpan.pos < errorSpan.end ? errorSpan : node; + } + + export function isExternalModule(file: SourceFile): boolean { + return file.externalModuleIndicator !== undefined; + } + + export function isDeclarationFile(file: SourceFile): boolean { + return (file.flags & NodeFlags.DeclarationFile) !== 0; + } + + export function isConstEnumDeclaration(node: Node): boolean { + return node.kind === SyntaxKind.EnumDeclaration && isConst(node); + } + + export function isConst(node: Node): boolean { + return !!(node.flags & NodeFlags.Const); + } + + export function isLet(node: Node): boolean { + return !!(node.flags & NodeFlags.Let); + } + + export function isPrologueDirective(node: Node): boolean { + return node.kind === SyntaxKind.ExpressionStatement && (node).expression.kind === SyntaxKind.StringLiteral; + } + + export function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile) { + sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node); + + // If parameter/type parameter, the prev token trailing comments are part of this node too + if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) { + // e.g. (/** blah */ a, /** blah */ b); + return concatenate(getTrailingCommentRanges(sourceFileOfNode.text, node.pos), + // e.g.: ( + // /** blah */ a, + // /** blah */ b); + getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); + } + else { + return getLeadingCommentRanges(sourceFileOfNode.text, node.pos); + } + } + + export function getJsDocComments(node: Node, sourceFileOfNode: SourceFile) { + return filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), isJsDocComment); + + function isJsDocComment(comment: CommentRange) { + // True if the comment starts with '/**' but not if it is '/**/' + return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk && + sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk && + sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== CharacterCodes.slash; + } + } + + export var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/ + + + // Warning: This has the same semantics as the forEach family of functions, + // in that traversal terminates in the event that 'visitor' supplies a truthy value. + export function forEachReturnStatement(body: Block, visitor: (stmt: ReturnStatement) => T): T { + + return traverse(body); + + function traverse(node: Node): T { + switch (node.kind) { + case SyntaxKind.ReturnStatement: + return visitor(node); + case SyntaxKind.Block: + case SyntaxKind.IfStatement: + case SyntaxKind.DoStatement: + case SyntaxKind.WhileStatement: + case SyntaxKind.ForStatement: + case SyntaxKind.ForInStatement: + case SyntaxKind.WithStatement: + case SyntaxKind.SwitchStatement: + case SyntaxKind.CaseClause: + case SyntaxKind.DefaultClause: + case SyntaxKind.LabeledStatement: + case SyntaxKind.TryStatement: + case SyntaxKind.TryBlock: + case SyntaxKind.CatchClause: + case SyntaxKind.FinallyBlock: + return forEachChild(node, traverse); + } + } + } + + export function isAnyFunction(node: Node): boolean { + if (node) { + switch (node.kind) { + case SyntaxKind.FunctionExpression: + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.ArrowFunction: + case SyntaxKind.Method: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.Constructor: + return true; + } + } + + return false; + } + + export function isFunctionBlock(node: Node) { + return node !== undefined && node.kind === SyntaxKind.Block && isAnyFunction(node.parent); + } + + export function isObjectLiteralMethod(node: Node) { + return node !== undefined && node.kind === SyntaxKind.Method && node.parent.kind === SyntaxKind.ObjectLiteralExpression; + } + + export function getContainingFunction(node: Node): FunctionLikeDeclaration { + while (true) { + node = node.parent; + if (!node || isAnyFunction(node)) { + return node; + } + } + } + + export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node { + while (true) { + node = node.parent; + if (!node) { + return undefined; + } + switch (node.kind) { + case SyntaxKind.ArrowFunction: + if (!includeArrowFunctions) { + continue; + } + // Fall through + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionExpression: + case SyntaxKind.ModuleDeclaration: + case SyntaxKind.Property: + case SyntaxKind.Method: + case SyntaxKind.Constructor: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.EnumDeclaration: + case SyntaxKind.SourceFile: + return node; + } + } + } + + export function getSuperContainer(node: Node): Node { + while (true) { + node = node.parent; + if (!node) { + return undefined; + } + switch (node.kind) { + case SyntaxKind.Property: + case SyntaxKind.Method: + case SyntaxKind.Constructor: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + return node; + } + } + } + + export function getInvokedExpression(node: CallLikeExpression): Expression { + if (node.kind === SyntaxKind.TaggedTemplateExpression) { + return (node).tag; + } + + // Will either be a CallExpression or NewExpression. + return (node).expression; + } + + export function isExpression(node: Node): boolean { + switch (node.kind) { + case SyntaxKind.ThisKeyword: + case SyntaxKind.SuperKeyword: + case SyntaxKind.NullKeyword: + case SyntaxKind.TrueKeyword: + case SyntaxKind.FalseKeyword: + case SyntaxKind.RegularExpressionLiteral: + case SyntaxKind.ArrayLiteralExpression: + case SyntaxKind.ObjectLiteralExpression: + case SyntaxKind.PropertyAccessExpression: + case SyntaxKind.ElementAccessExpression: + case SyntaxKind.CallExpression: + case SyntaxKind.NewExpression: + case SyntaxKind.TaggedTemplateExpression: + case SyntaxKind.TypeAssertionExpression: + case SyntaxKind.ParenthesizedExpression: + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + case SyntaxKind.VoidExpression: + case SyntaxKind.DeleteExpression: + case SyntaxKind.TypeOfExpression: + case SyntaxKind.PrefixUnaryExpression: + case SyntaxKind.PostfixUnaryExpression: + case SyntaxKind.BinaryExpression: + case SyntaxKind.ConditionalExpression: + case SyntaxKind.TemplateExpression: + case SyntaxKind.NoSubstitutionTemplateLiteral: + case SyntaxKind.OmittedExpression: + return true; + case SyntaxKind.QualifiedName: + while (node.parent.kind === SyntaxKind.QualifiedName) { + node = node.parent; + } + + return node.parent.kind === SyntaxKind.TypeQuery; + case SyntaxKind.Identifier: + if (node.parent.kind === SyntaxKind.TypeQuery) { + return true; + } + // fall through + case SyntaxKind.NumericLiteral: + case SyntaxKind.StringLiteral: + var parent = node.parent; + switch (parent.kind) { + case SyntaxKind.VariableDeclaration: + case SyntaxKind.Parameter: + case SyntaxKind.Property: + case SyntaxKind.EnumMember: + case SyntaxKind.PropertyAssignment: + return (parent).initializer === node; + case SyntaxKind.ExpressionStatement: + case SyntaxKind.IfStatement: + case SyntaxKind.DoStatement: + case SyntaxKind.WhileStatement: + case SyntaxKind.ReturnStatement: + case SyntaxKind.WithStatement: + case SyntaxKind.SwitchStatement: + case SyntaxKind.CaseClause: + case SyntaxKind.ThrowStatement: + case SyntaxKind.SwitchStatement: + return (parent).expression === node; + case SyntaxKind.ForStatement: + return (parent).initializer === node || + (parent).condition === node || + (parent).iterator === node; + case SyntaxKind.ForInStatement: + return (parent).variable === node || + (parent).expression === node; + case SyntaxKind.TypeAssertionExpression: + return node === (parent).expression; + case SyntaxKind.TemplateSpan: + return node === (parent).expression; + default: + if (isExpression(parent)) { + return true; + } + } + } + return false; + } + + export function isExternalModuleImportDeclaration(node: Node) { + return node.kind === SyntaxKind.ImportDeclaration && (node).moduleReference.kind === SyntaxKind.ExternalModuleReference; + } + + export function getExternalModuleImportDeclarationExpression(node: Node) { + Debug.assert(isExternalModuleImportDeclaration(node)); + return ((node).moduleReference).expression; + } + + export function isInternalModuleImportDeclaration(node: Node) { + return node.kind === SyntaxKind.ImportDeclaration && (node).moduleReference.kind !== SyntaxKind.ExternalModuleReference; + } + + export function hasDotDotDotToken(node: Node) { + return node && node.kind === SyntaxKind.Parameter && (node).dotDotDotToken !== undefined; + } + + export function hasQuestionToken(node: Node) { + if (node) { + switch (node.kind) { + case SyntaxKind.Parameter: + return (node).questionToken !== undefined; + case SyntaxKind.Method: + return (node).questionToken !== undefined; + case SyntaxKind.ShorthandPropertyAssignment: + case SyntaxKind.PropertyAssignment: + case SyntaxKind.Property: + return (node).questionToken !== undefined; + } + } + + return false; + } + + export function hasRestParameters(s: SignatureDeclaration): boolean { + return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined; + } + + export function isLiteralKind(kind: SyntaxKind): boolean { + return SyntaxKind.FirstLiteralToken <= kind && kind <= SyntaxKind.LastLiteralToken; + } + + export function isTextualLiteralKind(kind: SyntaxKind): boolean { + return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; + } + + export function isTemplateLiteralKind(kind: SyntaxKind): boolean { + return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken; + } + + export function isInAmbientContext(node: Node): boolean { + while (node) { + if (node.flags & (NodeFlags.Ambient | NodeFlags.DeclarationFile)) return true; + node = node.parent; + } + return false; + } + + export function isDeclaration(node: Node): boolean { + switch (node.kind) { + case SyntaxKind.TypeParameter: + case SyntaxKind.Parameter: + case SyntaxKind.VariableDeclaration: + case SyntaxKind.Property: + case SyntaxKind.PropertyAssignment: + case SyntaxKind.ShorthandPropertyAssignment: + case SyntaxKind.EnumMember: + case SyntaxKind.Method: + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.Constructor: + case SyntaxKind.ClassDeclaration: + case SyntaxKind.InterfaceDeclaration: + case SyntaxKind.TypeAliasDeclaration: + case SyntaxKind.EnumDeclaration: + case SyntaxKind.ModuleDeclaration: + case SyntaxKind.ImportDeclaration: + return true; + } + return false; + } + + export function isStatement(n: Node): boolean { + switch (n.kind) { + case SyntaxKind.BreakStatement: + case SyntaxKind.ContinueStatement: + case SyntaxKind.DebuggerStatement: + case SyntaxKind.DoStatement: + case SyntaxKind.ExpressionStatement: + case SyntaxKind.EmptyStatement: + case SyntaxKind.ForInStatement: + case SyntaxKind.ForStatement: + case SyntaxKind.IfStatement: + case SyntaxKind.LabeledStatement: + case SyntaxKind.ReturnStatement: + case SyntaxKind.SwitchStatement: + case SyntaxKind.ThrowKeyword: + case SyntaxKind.TryStatement: + case SyntaxKind.VariableStatement: + case SyntaxKind.WhileStatement: + case SyntaxKind.WithStatement: + case SyntaxKind.ExportAssignment: + return true; + default: + return false; + } + } + + // True if the given identifier, string literal, or number literal is the name of a declaration node + export function isDeclarationOrFunctionExpressionOrCatchVariableName(name: Node): boolean { + if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) { + return false; + } + + var parent = name.parent; + if (isDeclaration(parent) || parent.kind === SyntaxKind.FunctionExpression) { + return (parent).name === name; + } + + if (parent.kind === SyntaxKind.CatchClause) { + return (parent).name === name; + } + + return false; + } + + export function getClassBaseTypeNode(node: ClassDeclaration) { + var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword); + return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; + } + + export function getClassImplementedTypeNodes(node: ClassDeclaration) { + var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword); + return heritageClause ? heritageClause.types : undefined; + } + + export function getInterfaceBaseTypeNodes(node: InterfaceDeclaration) { + var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword); + return heritageClause ? heritageClause.types : undefined; + } + + export function getHeritageClause(clauses: NodeArray, kind: SyntaxKind) { + if (clauses) { + for (var i = 0, n = clauses.length; i < n; i++) { + if (clauses[i].token === kind) { + return clauses[i]; + } + } + } + + return undefined; + } + + export function tryResolveScriptReference(program: Program, sourceFile: SourceFile, reference: FileReference) { + if (!program.getCompilerOptions().noResolve) { + var referenceFileName = isRootedDiskPath(reference.filename) ? reference.filename : combinePaths(getDirectoryPath(sourceFile.filename), reference.filename); + referenceFileName = getNormalizedAbsolutePath(referenceFileName, program.getCompilerHost().getCurrentDirectory()); + return program.getSourceFile(referenceFileName); + } + } + + export function getAncestor(node: Node, kind: SyntaxKind): Node { + switch (kind) { + // special-cases that can be come first + case SyntaxKind.ClassDeclaration: + while (node) { + switch (node.kind) { + case SyntaxKind.ClassDeclaration: + return node; + case SyntaxKind.EnumDeclaration: + case SyntaxKind.InterfaceDeclaration: + case SyntaxKind.TypeAliasDeclaration: + case SyntaxKind.ModuleDeclaration: + case SyntaxKind.ImportDeclaration: + // early exit cases - declarations cannot be nested in classes + return undefined; + default: + node = node.parent; + continue; + } + } + break; + default: + while (node) { + if (node.kind === kind) { + return node; + } + node = node.parent; + } + break; + } + + return undefined; + } + + export function getFileReferenceFromReferencePath(comment: string, commentRange: CommentRange): ReferencePathMatchResult { + var simpleReferenceRegEx = /^\/\/\/\s*/gim; + if (simpleReferenceRegEx.exec(comment)) { + if (isNoDefaultLibRegEx.exec(comment)) { + return { + isNoDefaultLib: true + } + } + else { + var matchResult = fullTripleSlashReferencePathRegEx.exec(comment); + if (matchResult) { + var start = commentRange.pos; + var end = commentRange.end; + return { + fileReference: { + pos: start, + end: end, + filename: matchResult[3] + }, + isNoDefaultLib: false + }; + } + else { + return { + diagnosticMessage: Diagnostics.Invalid_reference_directive_syntax, + isNoDefaultLib: false + }; + } + } + } + return undefined; + } + + export function isKeyword(token: SyntaxKind): boolean { + return SyntaxKind.FirstKeyword <= token && token <= SyntaxKind.LastKeyword; + } + + export function isTrivia(token: SyntaxKind) { + return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken; + } + + export function isModifier(token: SyntaxKind): boolean { + switch (token) { + case SyntaxKind.PublicKeyword: + case SyntaxKind.PrivateKeyword: + case SyntaxKind.ProtectedKeyword: + case SyntaxKind.StaticKeyword: + case SyntaxKind.ExportKeyword: + case SyntaxKind.DeclareKeyword: + case SyntaxKind.ConstKeyword: + return true; + } + return false; + } + +} \ No newline at end of file diff --git a/src/services/services.ts b/src/services/services.ts index 76f4fece035c3..7ce2893fd490b 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1643,106 +1643,16 @@ module ts { owners: string[]; } - export function displayPartsToString(displayParts: SymbolDisplayPart[]) { - if (displayParts) { - return map(displayParts, displayPart => displayPart.text).join(""); - } - - return ""; - } - export interface DisplayPartsSymbolWriter extends SymbolWriter { displayParts(): SymbolDisplayPart[]; } - var displayPartWriter = getDisplayPartWriter(); - function getDisplayPartWriter(): DisplayPartsSymbolWriter { - var displayParts: SymbolDisplayPart[]; - var lineStart: boolean; - var indent: number; - - resetWriter(); - return { - displayParts: () => displayParts, - writeKeyword: text => writeKind(text, SymbolDisplayPartKind.keyword), - writeOperator: text => writeKind(text, SymbolDisplayPartKind.operator), - writePunctuation: text => writeKind(text, SymbolDisplayPartKind.punctuation), - writeSpace: text => writeKind(text, SymbolDisplayPartKind.space), - writeStringLiteral: text => writeKind(text, SymbolDisplayPartKind.stringLiteral), - writeParameter: text => writeKind(text, SymbolDisplayPartKind.parameterName), - writeSymbol, - writeLine, - increaseIndent: () => { indent++; }, - decreaseIndent: () => { indent--; }, - clear: resetWriter, - trackSymbol: () => { } - }; - - function writeIndent() { - if (lineStart) { - var indentString = getIndentString(indent); - if (indentString) { - displayParts.push(displayPart(indentString, SymbolDisplayPartKind.space)); - } - lineStart = false; - } - } - - function writeKind(text: string, kind: SymbolDisplayPartKind) { - writeIndent(); - displayParts.push(displayPart(text, kind)); - } - - function writeSymbol(text: string, symbol: Symbol) { - writeIndent(); - displayParts.push(symbolPart(text, symbol)); - } - - function writeLine() { - displayParts.push(lineBreakPart()); - lineStart = true; - } - - function resetWriter() { - displayParts = [] - lineStart = true; - indent = 0; + export function displayPartsToString(displayParts: SymbolDisplayPart[]) { + if (displayParts) { + return map(displayParts, displayPart => displayPart.text).join(""); } - } - - function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart { - return { - text: text, - kind: SymbolDisplayPartKind[kind] - }; - } - - export function spacePart() { - return displayPart(" ", SymbolDisplayPartKind.space); - } - export function keywordPart(kind: SyntaxKind) { - return displayPart(tokenToString(kind), SymbolDisplayPartKind.keyword); - } - - export function punctuationPart(kind: SyntaxKind) { - return displayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation); - } - - export function operatorPart(kind: SyntaxKind) { - return displayPart(tokenToString(kind), SymbolDisplayPartKind.operator); - } - - export function textPart(text: string) { - return displayPart(text, SymbolDisplayPartKind.text); - } - - export function lineBreakPart() { - return displayPart("\n", SymbolDisplayPartKind.lineBreak); - } - - function isFirstDeclarationOfSymbolParameter(symbol: Symbol) { - return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter; + return ""; } function isLocalVariableOrFunction(symbol: Symbol) { @@ -1773,59 +1683,6 @@ module ts { }); } - export function symbolPart(text: string, symbol: Symbol) { - return displayPart(text, displayPartKind(symbol), symbol); - - function displayPartKind(symbol: Symbol): SymbolDisplayPartKind { - var flags = symbol.flags; - - if (flags & SymbolFlags.Variable) { - return isFirstDeclarationOfSymbolParameter(symbol) ? SymbolDisplayPartKind.parameterName : SymbolDisplayPartKind.localName; - } - else if (flags & SymbolFlags.Property) { return SymbolDisplayPartKind.propertyName; } - else if (flags & SymbolFlags.GetAccessor) { return SymbolDisplayPartKind.propertyName; } - else if (flags & SymbolFlags.SetAccessor) { return SymbolDisplayPartKind.propertyName; } - else if (flags & SymbolFlags.EnumMember) { return SymbolDisplayPartKind.enumMemberName; } - else if (flags & SymbolFlags.Function) { return SymbolDisplayPartKind.functionName; } - else if (flags & SymbolFlags.Class) { return SymbolDisplayPartKind.className; } - else if (flags & SymbolFlags.Interface) { return SymbolDisplayPartKind.interfaceName; } - else if (flags & SymbolFlags.Enum) { return SymbolDisplayPartKind.enumName; } - else if (flags & SymbolFlags.Module) { return SymbolDisplayPartKind.moduleName; } - else if (flags & SymbolFlags.Method) { return SymbolDisplayPartKind.methodName; } - else if (flags & SymbolFlags.TypeParameter) { return SymbolDisplayPartKind.typeParameterName; } - else if (flags & SymbolFlags.TypeAlias) { return SymbolDisplayPartKind.aliasName; } - else if (flags & SymbolFlags.Import) { return SymbolDisplayPartKind.aliasName; } - - - return SymbolDisplayPartKind.text; - } - } - - export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[] { - writeDisplayParts(displayPartWriter); - var result = displayPartWriter.displayParts(); - displayPartWriter.clear(); - return result; - } - - export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] { - return mapToDisplayParts(writer => { - typechecker.getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); - }); - } - - export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): SymbolDisplayPart[] { - return mapToDisplayParts(writer => { - typeChecker.getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags); - }); - } - - function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[]{ - return mapToDisplayParts(writer => { - typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); - }); - } - export function getDefaultCompilerOptions(): CompilerOptions { // Set "ScriptTarget.Latest" target by default for language service return { @@ -1834,20 +1691,6 @@ module ts { }; } - export function compareDataObjects(dst: any, src: any): boolean { - for (var e in dst) { - if (typeof dst[e] === "object") { - if (!compareDataObjects(dst[e], src[e])) - return false; - } - else if (typeof dst[e] !== "function") { - if (dst[e] !== src[e]) - return false; - } - } - return true; - } - export class OperationCanceledException { } export class CancellationTokenObject { @@ -2204,20 +2047,6 @@ module ts { } /// Helpers - export function getNodeModifiers(node: Node): string { - var flags = node.flags; - var result: string[] = []; - - if (flags & NodeFlags.Private) result.push(ScriptElementKindModifier.privateMemberModifier); - if (flags & NodeFlags.Protected) result.push(ScriptElementKindModifier.protectedMemberModifier); - if (flags & NodeFlags.Public) result.push(ScriptElementKindModifier.publicMemberModifier); - if (flags & NodeFlags.Static) result.push(ScriptElementKindModifier.staticModifier); - if (flags & NodeFlags.Export) result.push(ScriptElementKindModifier.exportedModifier); - if (isInAmbientContext(node)) result.push(ScriptElementKindModifier.ambientModifier); - - return result.length > 0 ? result.join(',') : ScriptElementKindModifier.none; - } - function getTargetLabel(referenceNode: Node, labelName: string): Identifier { while (referenceNode) { if (referenceNode.kind === SyntaxKind.LabeledStatement && (referenceNode).label.text === labelName) { diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 32551d9737b92..146ea141d7694 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -270,7 +270,21 @@ module ts { return n.getWidth() !== 0; } - export function getTypeArgumentOrTypeParameterList(node: Node): NodeArray { + export function getNodeModifiers(node: Node): string { + var flags = node.flags; + var result: string[] = []; + + if (flags & NodeFlags.Private) result.push(ScriptElementKindModifier.privateMemberModifier); + if (flags & NodeFlags.Protected) result.push(ScriptElementKindModifier.protectedMemberModifier); + if (flags & NodeFlags.Public) result.push(ScriptElementKindModifier.publicMemberModifier); + if (flags & NodeFlags.Static) result.push(ScriptElementKindModifier.staticModifier); + if (flags & NodeFlags.Export) result.push(ScriptElementKindModifier.exportedModifier); + if (isInAmbientContext(node)) result.push(ScriptElementKindModifier.ambientModifier); + + return result.length > 0 ? result.join(',') : ScriptElementKindModifier.none; + } + + export function getTypeArgumentOrTypeParameterList(node: Node): NodeArray { if (node.kind === SyntaxKind.TypeReference || node.kind === SyntaxKind.CallExpression) { return (node).typeArguments; } @@ -306,4 +320,166 @@ module ts { return isTemplateLiteralKind(node.kind) && (node.getStart() < position && position < node.getEnd()) || (!!node.isUnterminated && position === node.getEnd()); } + + export function compareDataObjects(dst: any, src: any): boolean { + for (var e in dst) { + if (typeof dst[e] === "object") { + if (!compareDataObjects(dst[e], src[e])) { + return false; + } + } + else if (typeof dst[e] !== "function") { + if (dst[e] !== src[e]) { + return false; + } + } + } + return true; + } +} + +// Display-part writer helpers +module ts { + export function isFirstDeclarationOfSymbolParameter(symbol: Symbol) { + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter; + } + + var displayPartWriter = getDisplayPartWriter(); + function getDisplayPartWriter(): DisplayPartsSymbolWriter { + var displayParts: SymbolDisplayPart[]; + var lineStart: boolean; + var indent: number; + + resetWriter(); + return { + displayParts: () => displayParts, + writeKeyword: text => writeKind(text, SymbolDisplayPartKind.keyword), + writeOperator: text => writeKind(text, SymbolDisplayPartKind.operator), + writePunctuation: text => writeKind(text, SymbolDisplayPartKind.punctuation), + writeSpace: text => writeKind(text, SymbolDisplayPartKind.space), + writeStringLiteral: text => writeKind(text, SymbolDisplayPartKind.stringLiteral), + writeParameter: text => writeKind(text, SymbolDisplayPartKind.parameterName), + writeSymbol, + writeLine, + increaseIndent: () => { indent++; }, + decreaseIndent: () => { indent--; }, + clear: resetWriter, + trackSymbol: () => { } + }; + + function writeIndent() { + if (lineStart) { + var indentString = getIndentString(indent); + if (indentString) { + displayParts.push(displayPart(indentString, SymbolDisplayPartKind.space)); + } + lineStart = false; + } + } + + function writeKind(text: string, kind: SymbolDisplayPartKind) { + writeIndent(); + displayParts.push(displayPart(text, kind)); + } + + function writeSymbol(text: string, symbol: Symbol) { + writeIndent(); + displayParts.push(symbolPart(text, symbol)); + } + + function writeLine() { + displayParts.push(lineBreakPart()); + lineStart = true; + } + + function resetWriter() { + displayParts = [] + lineStart = true; + indent = 0; + } + } + + export function symbolPart(text: string, symbol: Symbol) { + return displayPart(text, displayPartKind(symbol), symbol); + + function displayPartKind(symbol: Symbol): SymbolDisplayPartKind { + var flags = symbol.flags; + + if (flags & SymbolFlags.Variable) { + return isFirstDeclarationOfSymbolParameter(symbol) ? SymbolDisplayPartKind.parameterName : SymbolDisplayPartKind.localName; + } + else if (flags & SymbolFlags.Property) { return SymbolDisplayPartKind.propertyName; } + else if (flags & SymbolFlags.GetAccessor) { return SymbolDisplayPartKind.propertyName; } + else if (flags & SymbolFlags.SetAccessor) { return SymbolDisplayPartKind.propertyName; } + else if (flags & SymbolFlags.EnumMember) { return SymbolDisplayPartKind.enumMemberName; } + else if (flags & SymbolFlags.Function) { return SymbolDisplayPartKind.functionName; } + else if (flags & SymbolFlags.Class) { return SymbolDisplayPartKind.className; } + else if (flags & SymbolFlags.Interface) { return SymbolDisplayPartKind.interfaceName; } + else if (flags & SymbolFlags.Enum) { return SymbolDisplayPartKind.enumName; } + else if (flags & SymbolFlags.Module) { return SymbolDisplayPartKind.moduleName; } + else if (flags & SymbolFlags.Method) { return SymbolDisplayPartKind.methodName; } + else if (flags & SymbolFlags.TypeParameter) { return SymbolDisplayPartKind.typeParameterName; } + else if (flags & SymbolFlags.TypeAlias) { return SymbolDisplayPartKind.aliasName; } + else if (flags & SymbolFlags.Import) { return SymbolDisplayPartKind.aliasName; } + + + return SymbolDisplayPartKind.text; + } + } + + export function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart { + return { + text: text, + kind: SymbolDisplayPartKind[kind] + }; + } + + export function spacePart() { + return displayPart(" ", SymbolDisplayPartKind.space); + } + + export function keywordPart(kind: SyntaxKind) { + return displayPart(tokenToString(kind), SymbolDisplayPartKind.keyword); + } + + export function punctuationPart(kind: SyntaxKind) { + return displayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation); + } + + export function operatorPart(kind: SyntaxKind) { + return displayPart(tokenToString(kind), SymbolDisplayPartKind.operator); + } + + export function textPart(text: string) { + return displayPart(text, SymbolDisplayPartKind.text); + } + + export function lineBreakPart() { + return displayPart("\n", SymbolDisplayPartKind.lineBreak); + } + + export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[] { + writeDisplayParts(displayPartWriter); + var result = displayPartWriter.displayParts(); + displayPartWriter.clear(); + return result; + } + + export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] { + return mapToDisplayParts(writer => { + typechecker.getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); + }); + } + + export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): SymbolDisplayPart[] { + return mapToDisplayParts(writer => { + typeChecker.getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags); + }); + } + + export function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] { + return mapToDisplayParts(writer => { + typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); + }); + } } \ No newline at end of file From 38bf383f0301a720f2d5866c8a3b0f47e765869f Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Sun, 7 Dec 2014 22:17:39 -0800 Subject: [PATCH 15/19] Add tests for public declarations --- src/harness/harness.ts | 8 +- .../reference/APISample_node_compile.js | 1840 ++++++ .../reference/APISample_node_compile.types | 5647 +++++++++++++++++ .../reference/APISample_standalone_compile.js | 1836 ++++++ .../APISample_standalone_compile.types | 5641 ++++++++++++++++ .../cases/compiler/APISample_node_compile.ts | 11 + .../compiler/APISample_standalone_compile.ts | 7 + 7 files changed, 14989 insertions(+), 1 deletion(-) create mode 100644 tests/baselines/reference/APISample_node_compile.js create mode 100644 tests/baselines/reference/APISample_node_compile.types create mode 100644 tests/baselines/reference/APISample_standalone_compile.js create mode 100644 tests/baselines/reference/APISample_standalone_compile.types create mode 100644 tests/cases/compiler/APISample_node_compile.ts create mode 100644 tests/cases/compiler/APISample_standalone_compile.ts diff --git a/src/harness/harness.ts b/src/harness/harness.ts index e813b18b457b3..374d08af1781a 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -776,9 +776,15 @@ module Harness { case 'errortruncation': options.noErrorTruncation = setting.value === 'false'; break; + case 'preserveconstenums': options.preserveConstEnums = setting.value === 'true'; break; + + case 'includebuiltfile': + inputFiles.push({ unitName: setting.value, content: IO.readFile(libFolder + setting.value)}); + break; + default: throw new Error('Unsupported compiler setting ' + setting.flag); } @@ -1164,7 +1170,7 @@ module Harness { var optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm; // multiple matches on multiple lines // List of allowed metadata names - var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noemitonerror","noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames", "preserveconstenums"]; + var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noemitonerror", "noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames", "preserveconstenums", "includebuiltfile"]; function extractCompilerSettings(content: string): CompilerSetting[] { diff --git a/tests/baselines/reference/APISample_node_compile.js b/tests/baselines/reference/APISample_node_compile.js new file mode 100644 index 0000000000000..2329e7be57cfd --- /dev/null +++ b/tests/baselines/reference/APISample_node_compile.js @@ -0,0 +1,1840 @@ +//// [tests/cases/compiler/APISample_node_compile.ts] //// + +//// [APISample_node_compile.ts] + +import ts = require("typescript"); + +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0"); + +var program = ts.createProgram(["file1.ts"], {}, undefined); +//// [typescript.d.ts] +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +declare module ts { + interface Map { + [index: string]: T; + } + interface TextRange { + pos: number; + end: number; + } + const enum SyntaxKind { + Unknown = 0, + EndOfFileToken = 1, + SingleLineCommentTrivia = 2, + MultiLineCommentTrivia = 3, + NewLineTrivia = 4, + WhitespaceTrivia = 5, + NumericLiteral = 6, + StringLiteral = 7, + RegularExpressionLiteral = 8, + NoSubstitutionTemplateLiteral = 9, + TemplateHead = 10, + TemplateMiddle = 11, + TemplateTail = 12, + OpenBraceToken = 13, + CloseBraceToken = 14, + OpenParenToken = 15, + CloseParenToken = 16, + OpenBracketToken = 17, + CloseBracketToken = 18, + DotToken = 19, + DotDotDotToken = 20, + SemicolonToken = 21, + CommaToken = 22, + LessThanToken = 23, + GreaterThanToken = 24, + LessThanEqualsToken = 25, + GreaterThanEqualsToken = 26, + EqualsEqualsToken = 27, + ExclamationEqualsToken = 28, + EqualsEqualsEqualsToken = 29, + ExclamationEqualsEqualsToken = 30, + EqualsGreaterThanToken = 31, + PlusToken = 32, + MinusToken = 33, + AsteriskToken = 34, + SlashToken = 35, + PercentToken = 36, + PlusPlusToken = 37, + MinusMinusToken = 38, + LessThanLessThanToken = 39, + GreaterThanGreaterThanToken = 40, + GreaterThanGreaterThanGreaterThanToken = 41, + AmpersandToken = 42, + BarToken = 43, + CaretToken = 44, + ExclamationToken = 45, + TildeToken = 46, + AmpersandAmpersandToken = 47, + BarBarToken = 48, + QuestionToken = 49, + ColonToken = 50, + EqualsToken = 51, + PlusEqualsToken = 52, + MinusEqualsToken = 53, + AsteriskEqualsToken = 54, + SlashEqualsToken = 55, + PercentEqualsToken = 56, + LessThanLessThanEqualsToken = 57, + GreaterThanGreaterThanEqualsToken = 58, + GreaterThanGreaterThanGreaterThanEqualsToken = 59, + AmpersandEqualsToken = 60, + BarEqualsToken = 61, + CaretEqualsToken = 62, + Identifier = 63, + BreakKeyword = 64, + CaseKeyword = 65, + CatchKeyword = 66, + ClassKeyword = 67, + ConstKeyword = 68, + ContinueKeyword = 69, + DebuggerKeyword = 70, + DefaultKeyword = 71, + DeleteKeyword = 72, + DoKeyword = 73, + ElseKeyword = 74, + EnumKeyword = 75, + ExportKeyword = 76, + ExtendsKeyword = 77, + FalseKeyword = 78, + FinallyKeyword = 79, + ForKeyword = 80, + FunctionKeyword = 81, + IfKeyword = 82, + ImportKeyword = 83, + InKeyword = 84, + InstanceOfKeyword = 85, + NewKeyword = 86, + NullKeyword = 87, + ReturnKeyword = 88, + SuperKeyword = 89, + SwitchKeyword = 90, + ThisKeyword = 91, + ThrowKeyword = 92, + TrueKeyword = 93, + TryKeyword = 94, + TypeOfKeyword = 95, + VarKeyword = 96, + VoidKeyword = 97, + WhileKeyword = 98, + WithKeyword = 99, + ImplementsKeyword = 100, + InterfaceKeyword = 101, + LetKeyword = 102, + PackageKeyword = 103, + PrivateKeyword = 104, + ProtectedKeyword = 105, + PublicKeyword = 106, + StaticKeyword = 107, + YieldKeyword = 108, + AnyKeyword = 109, + BooleanKeyword = 110, + ConstructorKeyword = 111, + DeclareKeyword = 112, + GetKeyword = 113, + ModuleKeyword = 114, + RequireKeyword = 115, + NumberKeyword = 116, + SetKeyword = 117, + StringKeyword = 118, + TypeKeyword = 119, + Missing = 120, + QualifiedName = 121, + ComputedPropertyName = 122, + TypeParameter = 123, + Parameter = 124, + Property = 125, + Method = 126, + Constructor = 127, + GetAccessor = 128, + SetAccessor = 129, + CallSignature = 130, + ConstructSignature = 131, + IndexSignature = 132, + TypeReference = 133, + FunctionType = 134, + ConstructorType = 135, + TypeQuery = 136, + TypeLiteral = 137, + ArrayType = 138, + TupleType = 139, + UnionType = 140, + ParenthesizedType = 141, + ArrayLiteralExpression = 142, + ObjectLiteralExpression = 143, + PropertyAccessExpression = 144, + ElementAccessExpression = 145, + CallExpression = 146, + NewExpression = 147, + TaggedTemplateExpression = 148, + TypeAssertionExpression = 149, + ParenthesizedExpression = 150, + FunctionExpression = 151, + ArrowFunction = 152, + DeleteExpression = 153, + TypeOfExpression = 154, + VoidExpression = 155, + PrefixUnaryExpression = 156, + PostfixUnaryExpression = 157, + BinaryExpression = 158, + ConditionalExpression = 159, + TemplateExpression = 160, + YieldExpression = 161, + OmittedExpression = 162, + TemplateSpan = 163, + Block = 164, + VariableStatement = 165, + EmptyStatement = 166, + ExpressionStatement = 167, + IfStatement = 168, + DoStatement = 169, + WhileStatement = 170, + ForStatement = 171, + ForInStatement = 172, + ContinueStatement = 173, + BreakStatement = 174, + ReturnStatement = 175, + WithStatement = 176, + SwitchStatement = 177, + LabeledStatement = 178, + ThrowStatement = 179, + TryStatement = 180, + TryBlock = 181, + CatchBlock = 182, + FinallyBlock = 183, + DebuggerStatement = 184, + VariableDeclaration = 185, + FunctionDeclaration = 186, + FunctionBlock = 187, + ClassDeclaration = 188, + InterfaceDeclaration = 189, + TypeAliasDeclaration = 190, + EnumDeclaration = 191, + ModuleDeclaration = 192, + ModuleBlock = 193, + ImportDeclaration = 194, + ExportAssignment = 195, + CaseClause = 196, + DefaultClause = 197, + HeritageClause = 198, + PropertyAssignment = 199, + ShorthandPropertyAssignment = 200, + EnumMember = 201, + SourceFile = 202, + Program = 203, + SyntaxList = 204, + Count = 205, + FirstAssignment = 51, + LastAssignment = 62, + FirstReservedWord = 64, + LastReservedWord = 99, + FirstKeyword = 64, + LastKeyword = 119, + FirstFutureReservedWord = 100, + LastFutureReservedWord = 108, + FirstTypeNode = 133, + LastTypeNode = 141, + FirstPunctuation = 13, + LastPunctuation = 62, + FirstToken = 1, + LastToken = 119, + FirstTriviaToken = 2, + LastTriviaToken = 5, + FirstLiteralToken = 6, + LastLiteralToken = 9, + FirstTemplateToken = 9, + LastTemplateToken = 12, + FirstOperator = 21, + LastOperator = 62, + FirstBinaryOperator = 23, + LastBinaryOperator = 62, + } + const enum NodeFlags { + Export = 1, + Ambient = 2, + QuestionMark = 4, + Rest = 8, + Public = 16, + Private = 32, + Protected = 64, + Static = 128, + MultiLine = 256, + Synthetic = 512, + DeclarationFile = 1024, + Let = 2048, + Const = 4096, + OctalLiteral = 8192, + Modifier = 243, + AccessibilityModifier = 112, + BlockScoped = 6144, + } + const enum ParserContextFlags { + StrictMode = 1, + DisallowIn = 2, + Yield = 4, + GeneratorParameter = 8, + } + interface Node extends TextRange { + kind: SyntaxKind; + flags: NodeFlags; + parserContextFlags?: ParserContextFlags; + id?: number; + parent?: Node; + symbol?: Symbol; + locals?: SymbolTable; + nextContainer?: Node; + localSymbol?: Symbol; + modifiers?: ModifiersArray; + } + interface NodeArray extends Array, TextRange { + hasTrailingComma?: boolean; + } + interface ModifiersArray extends Array { + flags: number; + } + interface Identifier extends PrimaryExpression { + text: string; + } + interface QualifiedName extends Node { + left: EntityName; + right: Identifier; + } + type EntityName = Identifier | QualifiedName; + interface ParsedSignature { + typeParameters?: NodeArray; + parameters: NodeArray; + type?: TypeNode; + } + type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; + interface Declaration extends Node { + _declarationBrand: any; + name?: DeclarationName; + } + interface ComputedPropertyName extends Node { + expression: Expression; + } + interface TypeParameterDeclaration extends Declaration { + name: Identifier; + constraint?: TypeNode; + expression?: Expression; + } + interface SignatureDeclaration extends Declaration, ParsedSignature { + } + interface VariableDeclaration extends Declaration { + name: Identifier; + type?: TypeNode; + initializer?: Expression; + } + interface PropertyDeclaration extends Declaration, ClassElement { + type?: TypeNode; + initializer?: Expression; + } + interface ShortHandPropertyDeclaration extends Declaration { + name: Identifier; + } + interface ParameterDeclaration extends VariableDeclaration { + } + /** + * Several node kinds share function-like features such as a signature, + * a name, and a body. These nodes should extend FunctionLikeDeclaration. + * Examples: + * FunctionDeclaration + * MethodDeclaration + * AccessorDeclaration + */ + interface FunctionLikeDeclaration extends SignatureDeclaration { + _functionLikeDeclarationBrand: any; + asteriskToken?: Node; + body?: Block | Expression; + } + interface FunctionDeclaration extends FunctionLikeDeclaration, Statement { + name: Identifier; + body?: Block; + } + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { + body?: Block; + } + interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement { + body?: Block; + } + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { + body?: Block; + } + interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement { + _indexSignatureDeclarationBrand: any; + } + interface TypeNode extends Node { + } + interface TypeReferenceNode extends TypeNode { + typeName: EntityName; + typeArguments?: NodeArray; + } + interface TypeQueryNode extends TypeNode { + exprName: EntityName; + } + interface TypeLiteralNode extends TypeNode, Declaration { + members: NodeArray; + } + interface ArrayTypeNode extends TypeNode { + elementType: TypeNode; + } + interface TupleTypeNode extends TypeNode { + elementTypes: NodeArray; + } + interface UnionTypeNode extends TypeNode { + types: NodeArray; + } + interface ParenthesizedTypeNode extends TypeNode { + type: TypeNode; + } + interface StringLiteralTypeNode extends TypeNode { + text: string; + } + interface Expression extends Node { + _expressionBrand: any; + contextualType?: Type; + } + interface UnaryExpression extends Expression { + _unaryExpressionBrand: any; + } + interface PrefixUnaryExpression extends UnaryExpression { + operator: SyntaxKind; + operand: UnaryExpression; + } + interface PostfixUnaryExpression extends PostfixExpression { + operand: LeftHandSideExpression; + operator: SyntaxKind; + } + interface PostfixExpression extends UnaryExpression { + _postfixExpressionBrand: any; + } + interface LeftHandSideExpression extends PostfixExpression { + _leftHandSideExpressionBrand: any; + } + interface MemberExpression extends LeftHandSideExpression { + _memberExpressionBrand: any; + } + interface PrimaryExpression extends MemberExpression { + _primaryExpressionBrand: any; + } + interface DeleteExpression extends UnaryExpression { + expression: UnaryExpression; + } + interface TypeOfExpression extends UnaryExpression { + expression: UnaryExpression; + } + interface VoidExpression extends UnaryExpression { + expression: UnaryExpression; + } + interface YieldExpression extends Expression { + asteriskToken?: Node; + expression: Expression; + } + interface BinaryExpression extends Expression { + left: Expression; + operator: SyntaxKind; + right: Expression; + } + interface ConditionalExpression extends Expression { + condition: Expression; + whenTrue: Expression; + whenFalse: Expression; + } + interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration { + name?: Identifier; + body: Block | Expression; + } + interface LiteralExpression extends PrimaryExpression { + text: string; + } + interface TemplateExpression extends PrimaryExpression { + head: LiteralExpression; + templateSpans: NodeArray; + } + interface TemplateSpan extends Node { + expression: Expression; + literal: LiteralExpression; + } + interface ParenthesizedExpression extends PrimaryExpression { + expression: Expression; + } + interface ArrayLiteralExpression extends PrimaryExpression { + elements: NodeArray; + } + interface ObjectLiteralExpression extends PrimaryExpression, Declaration { + properties: NodeArray; + } + interface PropertyAccessExpression extends MemberExpression { + expression: LeftHandSideExpression; + name: Identifier; + } + interface ElementAccessExpression extends MemberExpression { + expression: LeftHandSideExpression; + argumentExpression: Expression; + } + interface CallExpression extends LeftHandSideExpression { + expression: LeftHandSideExpression; + typeArguments?: NodeArray; + arguments: NodeArray; + } + interface NewExpression extends CallExpression, PrimaryExpression { + } + interface TaggedTemplateExpression extends MemberExpression { + tag: LeftHandSideExpression; + template: LiteralExpression | TemplateExpression; + } + type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; + interface TypeAssertion extends UnaryExpression { + type: TypeNode; + expression: UnaryExpression; + } + interface Statement extends Node, ModuleElement { + _statementBrand: any; + } + interface Block extends Statement { + statements: NodeArray; + } + interface VariableStatement extends Statement { + declarations: NodeArray; + } + interface ExpressionStatement extends Statement { + expression: Expression; + } + interface IfStatement extends Statement { + expression: Expression; + thenStatement: Statement; + elseStatement?: Statement; + } + interface IterationStatement extends Statement { + statement: Statement; + } + interface DoStatement extends IterationStatement { + expression: Expression; + } + interface WhileStatement extends IterationStatement { + expression: Expression; + } + interface ForStatement extends IterationStatement { + declarations?: NodeArray; + initializer?: Expression; + condition?: Expression; + iterator?: Expression; + } + interface ForInStatement extends IterationStatement { + declarations?: NodeArray; + variable?: Expression; + expression: Expression; + } + interface BreakOrContinueStatement extends Statement { + label?: Identifier; + } + interface ReturnStatement extends Statement { + expression?: Expression; + } + interface WithStatement extends Statement { + expression: Expression; + statement: Statement; + } + interface SwitchStatement extends Statement { + expression: Expression; + clauses: NodeArray; + } + interface CaseOrDefaultClause extends Node { + expression?: Expression; + statements: NodeArray; + } + interface LabeledStatement extends Statement { + label: Identifier; + statement: Statement; + } + interface ThrowStatement extends Statement { + expression: Expression; + } + interface TryStatement extends Statement { + tryBlock: Block; + catchBlock?: CatchBlock; + finallyBlock?: Block; + } + interface CatchBlock extends Block, Declaration { + variable: Identifier; + type?: TypeNode; + } + interface ModuleElement extends Node { + _moduleElementBrand: any; + } + interface ClassDeclaration extends Declaration, ModuleElement { + name: Identifier; + typeParameters?: NodeArray; + heritageClauses?: NodeArray; + members: NodeArray; + } + interface ClassElement extends Declaration { + _classElementBrand: any; + } + interface InterfaceDeclaration extends Declaration, ModuleElement { + name: Identifier; + typeParameters?: NodeArray; + heritageClauses?: NodeArray; + members: NodeArray; + } + interface HeritageClause extends Node { + token: SyntaxKind; + types?: NodeArray; + } + interface TypeAliasDeclaration extends Declaration, ModuleElement { + name: Identifier; + type: TypeNode; + } + interface EnumMember extends Declaration { + name: DeclarationName; + initializer?: Expression; + } + interface EnumDeclaration extends Declaration, ModuleElement { + name: Identifier; + members: NodeArray; + } + interface ModuleDeclaration extends Declaration, ModuleElement { + name: Identifier | LiteralExpression; + body: ModuleBlock | ModuleDeclaration; + } + interface ModuleBlock extends Node, ModuleElement { + statements: NodeArray; + } + interface ImportDeclaration extends Declaration, ModuleElement { + name: Identifier; + entityName?: EntityName; + externalModuleName?: LiteralExpression; + } + interface ExportAssignment extends Statement, ModuleElement { + exportName: Identifier; + } + interface FileReference extends TextRange { + filename: string; + } + interface CommentRange extends TextRange { + hasTrailingNewLine?: boolean; + } + interface SourceFile extends Declaration { + statements: NodeArray; + filename: string; + text: string; + getLineAndCharacterFromPosition(position: number): LineAndCharacter; + getPositionFromLineAndCharacter(line: number, character: number): number; + getLineStarts(): number[]; + amdDependencies: string[]; + amdModuleName: string; + referencedFiles: FileReference[]; + semanticDiagnostics: Diagnostic[]; + parseDiagnostics: Diagnostic[]; + grammarDiagnostics: Diagnostic[]; + getSyntacticDiagnostics(): Diagnostic[]; + hasNoDefaultLib: boolean; + externalModuleIndicator: Node; + nodeCount: number; + identifierCount: number; + symbolCount: number; + isOpen: boolean; + version: string; + languageVersion: ScriptTarget; + identifiers: Map; + } + interface Program { + getSourceFile(filename: string): SourceFile; + getSourceFiles(): SourceFile[]; + getCompilerOptions(): CompilerOptions; + getCompilerHost(): CompilerHost; + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; + getGlobalDiagnostics(): Diagnostic[]; + getTypeChecker(fullTypeCheckMode: boolean): TypeChecker; + getCommonSourceDirectory(): string; + } + interface SourceMapSpan { + emittedLine: number; + emittedColumn: number; + sourceLine: number; + sourceColumn: number; + nameIndex?: number; + sourceIndex: number; + } + interface SourceMapData { + sourceMapFilePath: string; + jsSourceMappingURL: string; + sourceMapFile: string; + sourceMapSourceRoot: string; + sourceMapSources: string[]; + inputSourceFileNames: string[]; + sourceMapNames?: string[]; + sourceMapMappings: string; + sourceMapDecodedMappings: SourceMapSpan[]; + } + enum EmitReturnStatus { + Succeeded = 0, + AllOutputGenerationSkipped = 1, + JSGeneratedWithSemanticErrors = 2, + DeclarationGenerationSkipped = 3, + EmitErrorsEncountered = 4, + CompilerOptionsErrors = 5, + } + interface EmitResult { + emitResultStatus: EmitReturnStatus; + diagnostics: Diagnostic[]; + sourceMaps: SourceMapData[]; + } + interface TypeChecker { + getProgram(): Program; + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; + getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[]; + getGlobalDiagnostics(): Diagnostic[]; + getNodeCount(): number; + getIdentifierCount(): number; + getSymbolCount(): number; + getTypeCount(): number; + checkProgram(): void; + emitFiles(targetSourceFile?: SourceFile): EmitResult; + getParentOfSymbol(symbol: Symbol): Symbol; + getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; + getDeclaredTypeOfSymbol(symbol: Symbol): Type; + getPropertiesOfType(type: Type): Symbol[]; + getPropertyOfType(type: Type, propertyName: string): Symbol; + getSignaturesOfType(type: Type, kind: SignatureKind): Signature[]; + getIndexTypeOfType(type: Type, kind: IndexKind): Type; + getReturnTypeOfSignature(signature: Signature): Type; + getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; + getSymbolInfo(node: Node): Symbol; + getShorthandAssignmentValueSymbol(location: Node): Symbol; + getTypeOfNode(node: Node): Type; + typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; + symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; + getSymbolDisplayBuilder(): SymbolDisplayBuilder; + getFullyQualifiedName(symbol: Symbol): string; + getAugmentedPropertiesOfType(type: Type): Symbol[]; + getRootSymbols(symbol: Symbol): Symbol[]; + getContextualType(node: Node): Type; + getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; + getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature; + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; + isUndefinedSymbol(symbol: Symbol): boolean; + isArgumentsSymbol(symbol: Symbol): boolean; + isEmitBlocked(sourceFile?: SourceFile): boolean; + getEnumMemberValue(node: EnumMember): number; + isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; + getAliasedSymbol(symbol: Symbol): Symbol; + } + interface SymbolDisplayBuilder { + buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void; + buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void; + buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + } + interface SymbolWriter { + writeKeyword(text: string): void; + writeOperator(text: string): void; + writePunctuation(text: string): void; + writeSpace(text: string): void; + writeStringLiteral(text: string): void; + writeParameter(text: string): void; + writeSymbol(text: string, symbol: Symbol): void; + writeLine(): void; + increaseIndent(): void; + decreaseIndent(): void; + clear(): void; + trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void; + } + const enum TypeFormatFlags { + None = 0, + WriteArrayAsGenericType = 1, + UseTypeOfFunction = 2, + NoTruncation = 4, + WriteArrowStyleSignature = 8, + WriteOwnNameForAnyLike = 16, + WriteTypeArgumentsOfSignature = 32, + InElementType = 64, + } + const enum SymbolFormatFlags { + None = 0, + WriteTypeParametersOrArguments = 1, + UseOnlyExternalAliasing = 2, + } + const enum SymbolAccessibility { + Accessible = 0, + NotAccessible = 1, + CannotBeNamed = 2, + } + interface SymbolVisibilityResult { + accessibility: SymbolAccessibility; + aliasesToMakeVisible?: ImportDeclaration[]; + errorSymbolName?: string; + errorNode?: Node; + } + interface SymbolAccessiblityResult extends SymbolVisibilityResult { + errorModuleName?: string; + } + interface EmitResolver { + getProgram(): Program; + getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string; + getExpressionNamePrefix(node: Identifier): string; + getExportAssignmentName(node: SourceFile): string; + isReferencedImportDeclaration(node: ImportDeclaration): boolean; + isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; + getNodeCheckFlags(node: Node): NodeCheckFlags; + getEnumMemberValue(node: EnumMember): number; + hasSemanticErrors(): boolean; + isDeclarationVisible(node: Declaration): boolean; + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; + writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; + writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; + isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult; + isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult; + getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number; + isEmitBlocked(sourceFile?: SourceFile): boolean; + } + const enum SymbolFlags { + FunctionScopedVariable = 1, + BlockScopedVariable = 2, + Property = 4, + EnumMember = 8, + Function = 16, + Class = 32, + Interface = 64, + ConstEnum = 128, + RegularEnum = 256, + ValueModule = 512, + NamespaceModule = 1024, + TypeLiteral = 2048, + ObjectLiteral = 4096, + Method = 8192, + Constructor = 16384, + GetAccessor = 32768, + SetAccessor = 65536, + CallSignature = 131072, + ConstructSignature = 262144, + IndexSignature = 524288, + TypeParameter = 1048576, + TypeAlias = 2097152, + ExportValue = 4194304, + ExportType = 8388608, + ExportNamespace = 16777216, + Import = 33554432, + Instantiated = 67108864, + Merged = 134217728, + Transient = 268435456, + Prototype = 536870912, + UnionProperty = 1073741824, + Enum = 384, + Variable = 3, + Value = 107455, + Type = 3152352, + Namespace = 1536, + Module = 1536, + Accessor = 98304, + Signature = 917504, + FunctionScopedVariableExcludes = 107454, + BlockScopedVariableExcludes = 107455, + ParameterExcludes = 107455, + PropertyExcludes = 107455, + EnumMemberExcludes = 107455, + FunctionExcludes = 106927, + ClassExcludes = 3258879, + InterfaceExcludes = 3152288, + RegularEnumExcludes = 3258623, + ConstEnumExcludes = 3259263, + ValueModuleExcludes = 106639, + NamespaceModuleExcludes = 0, + MethodExcludes = 99263, + GetAccessorExcludes = 41919, + SetAccessorExcludes = 74687, + TypeParameterExcludes = 2103776, + TypeAliasExcludes = 3152352, + ImportExcludes = 33554432, + ModuleMember = 35653619, + ExportHasLocal = 944, + HasLocals = 1041936, + HasExports = 1952, + HasMembers = 6240, + IsContainer = 1048560, + PropertyOrAccessor = 98308, + Export = 29360128, + } + interface Symbol { + flags: SymbolFlags; + name: string; + id?: number; + mergeId?: number; + declarations?: Declaration[]; + parent?: Symbol; + members?: SymbolTable; + exports?: SymbolTable; + exportSymbol?: Symbol; + valueDeclaration?: Declaration; + constEnumOnlyModule?: boolean; + } + interface SymbolLinks { + target?: Symbol; + type?: Type; + declaredType?: Type; + mapper?: TypeMapper; + referenced?: boolean; + exportAssignSymbol?: Symbol; + unionType?: UnionType; + } + interface TransientSymbol extends Symbol, SymbolLinks { + } + interface SymbolTable { + [index: string]: Symbol; + } + const enum NodeCheckFlags { + TypeChecked = 1, + LexicalThis = 2, + CaptureThis = 4, + EmitExtends = 8, + SuperInstance = 16, + SuperStatic = 32, + ContextChecked = 64, + EnumValuesComputed = 128, + } + interface NodeLinks { + resolvedType?: Type; + resolvedSignature?: Signature; + resolvedSymbol?: Symbol; + flags?: NodeCheckFlags; + enumMemberValue?: number; + isIllegalTypeReferenceInConstraint?: boolean; + isVisible?: boolean; + localModuleName?: string; + assignmentChecks?: Map; + } + const enum TypeFlags { + Any = 1, + String = 2, + Number = 4, + Boolean = 8, + Void = 16, + Undefined = 32, + Null = 64, + Enum = 128, + StringLiteral = 256, + TypeParameter = 512, + Class = 1024, + Interface = 2048, + Reference = 4096, + Tuple = 8192, + Union = 16384, + Anonymous = 32768, + FromSignature = 65536, + Intrinsic = 127, + StringLike = 258, + NumberLike = 132, + ObjectType = 48128, + Structured = 65025, + } + interface Type { + flags: TypeFlags; + id: number; + symbol?: Symbol; + } + interface IntrinsicType extends Type { + intrinsicName: string; + } + interface StringLiteralType extends Type { + text: string; + } + interface ObjectType extends Type { + } + interface InterfaceType extends ObjectType { + typeParameters: TypeParameter[]; + baseTypes: ObjectType[]; + declaredProperties: Symbol[]; + declaredCallSignatures: Signature[]; + declaredConstructSignatures: Signature[]; + declaredStringIndexType: Type; + declaredNumberIndexType: Type; + } + interface TypeReference extends ObjectType { + target: GenericType; + typeArguments: Type[]; + } + interface GenericType extends InterfaceType, TypeReference { + instantiations: Map; + openReferenceTargets: GenericType[]; + openReferenceChecks: Map; + } + interface TupleType extends ObjectType { + elementTypes: Type[]; + baseArrayType: TypeReference; + } + interface UnionType extends Type { + types: Type[]; + resolvedProperties: SymbolTable; + } + interface ResolvedType extends ObjectType, UnionType { + members: SymbolTable; + properties: Symbol[]; + callSignatures: Signature[]; + constructSignatures: Signature[]; + stringIndexType: Type; + numberIndexType: Type; + } + interface TypeParameter extends Type { + constraint: Type; + target?: TypeParameter; + mapper?: TypeMapper; + } + const enum SignatureKind { + Call = 0, + Construct = 1, + } + interface Signature { + declaration: SignatureDeclaration; + typeParameters: TypeParameter[]; + parameters: Symbol[]; + resolvedReturnType: Type; + minArgumentCount: number; + hasRestParameter: boolean; + hasStringLiterals: boolean; + target?: Signature; + mapper?: TypeMapper; + unionSignatures?: Signature[]; + erasedSignatureCache?: Signature; + isolatedSignatureType?: ObjectType; + } + const enum IndexKind { + String = 0, + Number = 1, + } + interface TypeMapper { + (t: Type): Type; + } + interface TypeInferences { + primary: Type[]; + secondary: Type[]; + } + interface InferenceContext { + typeParameters: TypeParameter[]; + inferUnionTypes: boolean; + inferences: TypeInferences[]; + inferredTypes: Type[]; + failedTypeParameterIndex?: number; + } + interface DiagnosticMessage { + key: string; + category: DiagnosticCategory; + code: number; + isEarly?: boolean; + } + interface DiagnosticMessageChain { + messageText: string; + category: DiagnosticCategory; + code: number; + next?: DiagnosticMessageChain; + } + interface Diagnostic { + file: SourceFile; + start: number; + length: number; + messageText: string; + category: DiagnosticCategory; + code: number; + /** + * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit + */ + isEarly?: boolean; + /** + * Parse error - error produced by parser when it scanner returns a token + * that parser does not understand in its current state + * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) + */ + isParseError?: boolean; + } + enum DiagnosticCategory { + Warning = 0, + Error = 1, + Message = 2, + } + interface CompilerOptions { + charset?: string; + codepage?: number; + declaration?: boolean; + diagnostics?: boolean; + emitBOM?: boolean; + help?: boolean; + locale?: string; + mapRoot?: string; + module?: ModuleKind; + noEmitOnError?: boolean; + noErrorTruncation?: boolean; + noImplicitAny?: boolean; + noLib?: boolean; + noLibCheck?: boolean; + noResolve?: boolean; + out?: string; + outDir?: string; + removeComments?: boolean; + sourceMap?: boolean; + sourceRoot?: string; + target?: ScriptTarget; + version?: boolean; + watch?: boolean; + preserveConstEnums?: boolean; + [option: string]: string | number | boolean; + } + const enum ModuleKind { + None = 0, + CommonJS = 1, + AMD = 2, + } + interface LineAndCharacter { + line: number; + character: number; + } + const enum ScriptTarget { + ES3 = 0, + ES5 = 1, + ES6 = 2, + Latest = 2, + } + interface ParsedCommandLine { + options: CompilerOptions; + filenames: string[]; + errors: Diagnostic[]; + } + interface CommandLineOption { + name: string; + type: string | Map; + shortName?: string; + description?: DiagnosticMessage; + paramName?: DiagnosticMessage; + error?: DiagnosticMessage; + } + const enum CharacterCodes { + nullCharacter = 0, + maxAsciiCharacter = 127, + lineFeed = 10, + carriageReturn = 13, + lineSeparator = 8232, + paragraphSeparator = 8233, + nextLine = 133, + space = 32, + nonBreakingSpace = 160, + enQuad = 8192, + emQuad = 8193, + enSpace = 8194, + emSpace = 8195, + threePerEmSpace = 8196, + fourPerEmSpace = 8197, + sixPerEmSpace = 8198, + figureSpace = 8199, + punctuationSpace = 8200, + thinSpace = 8201, + hairSpace = 8202, + zeroWidthSpace = 8203, + narrowNoBreakSpace = 8239, + ideographicSpace = 12288, + mathematicalSpace = 8287, + ogham = 5760, + _ = 95, + $ = 36, + _0 = 48, + _1 = 49, + _2 = 50, + _3 = 51, + _4 = 52, + _5 = 53, + _6 = 54, + _7 = 55, + _8 = 56, + _9 = 57, + a = 97, + b = 98, + c = 99, + d = 100, + e = 101, + f = 102, + g = 103, + h = 104, + i = 105, + j = 106, + k = 107, + l = 108, + m = 109, + n = 110, + o = 111, + p = 112, + q = 113, + r = 114, + s = 115, + t = 116, + u = 117, + v = 118, + w = 119, + x = 120, + y = 121, + z = 122, + A = 65, + B = 66, + C = 67, + D = 68, + E = 69, + F = 70, + G = 71, + H = 72, + I = 73, + J = 74, + K = 75, + L = 76, + M = 77, + N = 78, + O = 79, + P = 80, + Q = 81, + R = 82, + S = 83, + T = 84, + U = 85, + V = 86, + W = 87, + X = 88, + Y = 89, + Z = 90, + ampersand = 38, + asterisk = 42, + at = 64, + backslash = 92, + backtick = 96, + bar = 124, + caret = 94, + closeBrace = 125, + closeBracket = 93, + closeParen = 41, + colon = 58, + comma = 44, + dot = 46, + doubleQuote = 34, + equals = 61, + exclamation = 33, + greaterThan = 62, + lessThan = 60, + minus = 45, + openBrace = 123, + openBracket = 91, + openParen = 40, + percent = 37, + plus = 43, + question = 63, + semicolon = 59, + singleQuote = 39, + slash = 47, + tilde = 126, + backspace = 8, + formFeed = 12, + byteOrderMark = 65279, + tab = 9, + verticalTab = 11, + } + interface CancellationToken { + isCancellationRequested(): boolean; + } + interface CompilerHost { + getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; + getDefaultLibFilename(): string; + getCancellationToken?(): CancellationToken; + writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; + getCurrentDirectory(): string; + getCanonicalFileName(fileName: string): string; + useCaseSensitiveFileNames(): boolean; + getNewLine(): string; + } +} +declare module ts { + interface ErrorCallback { + (message: DiagnosticMessage): void; + } + interface CommentCallback { + (pos: number, end: number): void; + } + interface Scanner { + getStartPos(): number; + getToken(): SyntaxKind; + getTextPos(): number; + getTokenPos(): number; + getTokenText(): string; + getTokenValue(): string; + hasPrecedingLineBreak(): boolean; + isIdentifier(): boolean; + isReservedWord(): boolean; + reScanGreaterToken(): SyntaxKind; + reScanSlashToken(): SyntaxKind; + reScanTemplateToken(): SyntaxKind; + scan(): SyntaxKind; + setText(text: string): void; + setTextPos(textPos: number): void; + tryScan(callback: () => T): T; + } + function tokenToString(t: SyntaxKind): string; + function computeLineStarts(text: string): number[]; + function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number; + function getLineAndCharacterOfPosition(lineStarts: number[], position: number): { + line: number; + character: number; + }; + function positionToLineAndCharacter(text: string, pos: number): { + line: number; + character: number; + }; + function isWhiteSpace(ch: number): boolean; + function isLineBreak(ch: number): boolean; + function isOctalDigit(ch: number): boolean; + function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number; + function getLeadingCommentRanges(text: string, pos: number): CommentRange[]; + function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; + function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; + function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; +} +declare module ts { + interface ReferencePathMatchResult { + fileReference?: FileReference; + diagnostic?: DiagnosticMessage; + isNoDefaultLib?: boolean; + } + function getNodeConstructor(kind: SyntaxKind): new () => Node; + function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; + function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; + function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program; +} +declare module ts { + function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker; +} +declare module ts { + interface Node { + getSourceFile(): SourceFile; + getChildCount(sourceFile?: SourceFile): number; + getChildAt(index: number, sourceFile?: SourceFile): Node; + getChildren(sourceFile?: SourceFile): Node[]; + getStart(sourceFile?: SourceFile): number; + getFullStart(): number; + getEnd(): number; + getWidth(sourceFile?: SourceFile): number; + getFullWidth(): number; + getLeadingTriviaWidth(sourceFile?: SourceFile): number; + getFullText(sourceFile?: SourceFile): string; + getText(sourceFile?: SourceFile): string; + getFirstToken(sourceFile?: SourceFile): Node; + getLastToken(sourceFile?: SourceFile): Node; + } + interface Symbol { + getFlags(): SymbolFlags; + getName(): string; + getDeclarations(): Declaration[]; + getDocumentationComment(): SymbolDisplayPart[]; + } + interface Type { + getFlags(): TypeFlags; + getSymbol(): Symbol; + getProperties(): Symbol[]; + getProperty(propertyName: string): Symbol; + getApparentProperties(): Symbol[]; + getCallSignatures(): Signature[]; + getConstructSignatures(): Signature[]; + getStringIndexType(): Type; + getNumberIndexType(): Type; + } + interface Signature { + getDeclaration(): SignatureDeclaration; + getTypeParameters(): Type[]; + getParameters(): Symbol[]; + getReturnType(): Type; + getDocumentationComment(): SymbolDisplayPart[]; + } + interface SourceFile { + getScriptSnapshot(): IScriptSnapshot; + getNamedDeclarations(): Declaration[]; + update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; + } + /** + * Represents an immutable snapshot of a script at a specified time.Once acquired, the + * snapshot is observably immutable. i.e. the same calls with the same parameters will return + * the same values. + */ + interface IScriptSnapshot { + /** Gets a portion of the script snapshot specified by [start, end). */ + getText(start: number, end: number): string; + /** Gets the length of this script snapshot. */ + getLength(): number; + /** + * This call returns the array containing the start position of every line. + * i.e."[0, 10, 55]". TODO: consider making this optional. The language service could + * always determine this (albeit in a more expensive manner). + */ + getLineStartPositions(): number[]; + /** + * Gets the TextChangeRange that describe how the text changed between this text and + * an older version. This information is used by the incremental parser to determine + * what sections of the script need to be re-parsed. 'undefined' can be returned if the + * change range cannot be determined. However, in that case, incremental parsing will + * not happen and the entire document will be re - parsed. + */ + getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange; + } + module ScriptSnapshot { + function fromString(text: string): IScriptSnapshot; + } + interface PreProcessedFileInfo { + referencedFiles: FileReference[]; + importedFiles: FileReference[]; + isLibFile: boolean; + } + interface Logger { + log(s: string): void; + } + interface LanguageServiceHost extends Logger { + getCompilationSettings(): CompilerOptions; + getScriptFileNames(): string[]; + getScriptVersion(fileName: string): string; + getScriptIsOpen(fileName: string): boolean; + getScriptSnapshot(fileName: string): IScriptSnapshot; + getLocalizedDiagnosticMessages(): any; + getCancellationToken(): CancellationToken; + getCurrentDirectory(): string; + getDefaultLibFilename(): string; + } + interface LanguageService { + cleanupSemanticCache(): void; + getSyntacticDiagnostics(fileName: string): Diagnostic[]; + getSemanticDiagnostics(fileName: string): Diagnostic[]; + getCompilerOptionsDiagnostics(): Diagnostic[]; + getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; + getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; + getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; + getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan; + getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan; + getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems; + getRenameInfo(fileName: string, position: number): RenameInfo; + findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[]; + getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[]; + getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[]; + getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[]; + getNavigateToItems(searchValue: string): NavigateToItem[]; + getNavigationBarItems(fileName: string): NavigationBarItem[]; + getOutliningSpans(fileName: string): OutliningSpan[]; + getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[]; + getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[]; + getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number; + getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[]; + getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[]; + getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[]; + getEmitOutput(fileName: string): EmitOutput; + getSourceFile(filename: string): SourceFile; + dispose(): void; + } + class TextSpan { + private _start; + private _length; + /** + * Creates a TextSpan instance beginning with the position Start and having the Length + * specified with length. + */ + constructor(start: number, length: number); + toJSON(key: any): any; + start(): number; + length(): number; + end(): number; + isEmpty(): boolean; + /** + * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less + * than End, otherwise false. + * @param position The position to check. + */ + containsPosition(position: number): boolean; + /** + * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false. + * @param span The span to check. + */ + containsTextSpan(span: TextSpan): boolean; + /** + * Determines whether the given span overlaps this span. Two spans are considered to overlap + * if they have positions in common and neither is empty. Empty spans do not overlap with any + * other span. Returns true if the spans overlap, false otherwise. + * @param span The span to check. + */ + overlapsWith(span: TextSpan): boolean; + /** + * Returns the overlap with the given span, or undefined if there is no overlap. + * @param span The span to check. + */ + overlap(span: TextSpan): TextSpan; + /** + * Determines whether span intersects this span. Two spans are considered to + * intersect if they have positions in common or the end of one span + * coincides with the start of the other span. Returns true if the spans intersect, false otherwise. + * @param The span to check. + */ + intersectsWithTextSpan(span: TextSpan): boolean; + intersectsWith(start: number, length: number): boolean; + /** + * Determines whether the given position intersects this span. + * A position is considered to intersect if it is between the start and + * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise. + * @param position The position to check. + */ + intersectsWithPosition(position: number): boolean; + /** + * Returns the intersection with the given span, or undefined if there is no intersection. + * @param span The span to check. + */ + intersection(span: TextSpan): TextSpan; + /** + * Creates a new TextSpan from the given start and end positions + * as opposed to a position and length. + */ + static fromBounds(start: number, end: number): TextSpan; + } + class TextChangeRange { + static unchanged: TextChangeRange; + private _span; + private _newLength; + /** + * Initializes a new instance of TextChangeRange. + */ + constructor(span: TextSpan, newLength: number); + /** + * The span of text before the edit which is being changed + */ + span(): TextSpan; + /** + * Width of the span after the edit. A 0 here would represent a delete + */ + newLength(): number; + newSpan(): TextSpan; + isUnchanged(): boolean; + /** + * Called to merge all the changes that occurred across several versions of a script snapshot + * into a single change. i.e. if a user keeps making successive edits to a script we will + * have a text change from V1 to V2, V2 to V3, ..., Vn. + * + * This function will then merge those changes into a single change range valid between V1 and + * Vn. + */ + static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; + } + interface ClassifiedSpan { + textSpan: TextSpan; + classificationType: string; + } + interface NavigationBarItem { + text: string; + kind: string; + kindModifiers: string; + spans: TextSpan[]; + childItems: NavigationBarItem[]; + indent: number; + bolded: boolean; + grayed: boolean; + } + interface TodoCommentDescriptor { + text: string; + priority: number; + } + interface TodoComment { + descriptor: TodoCommentDescriptor; + message: string; + position: number; + } + class TextChange { + span: TextSpan; + newText: string; + } + interface RenameLocation { + textSpan: TextSpan; + fileName: string; + } + interface ReferenceEntry { + textSpan: TextSpan; + fileName: string; + isWriteAccess: boolean; + } + interface NavigateToItem { + name: string; + kind: string; + kindModifiers: string; + matchKind: string; + fileName: string; + textSpan: TextSpan; + containerName: string; + containerKind: string; + } + interface EditorOptions { + IndentSize: number; + TabSize: number; + NewLineCharacter: string; + ConvertTabsToSpaces: boolean; + } + interface FormatCodeOptions extends EditorOptions { + InsertSpaceAfterCommaDelimiter: boolean; + InsertSpaceAfterSemicolonInForStatements: boolean; + InsertSpaceBeforeAndAfterBinaryOperators: boolean; + InsertSpaceAfterKeywordsInControlFlowStatements: boolean; + InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean; + InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean; + PlaceOpenBraceOnNewLineForFunctions: boolean; + PlaceOpenBraceOnNewLineForControlBlocks: boolean; + } + interface DefinitionInfo { + fileName: string; + textSpan: TextSpan; + kind: string; + name: string; + containerKind: string; + containerName: string; + } + enum SymbolDisplayPartKind { + aliasName = 0, + className = 1, + enumName = 2, + fieldName = 3, + interfaceName = 4, + keyword = 5, + lineBreak = 6, + numericLiteral = 7, + stringLiteral = 8, + localName = 9, + methodName = 10, + moduleName = 11, + operator = 12, + parameterName = 13, + propertyName = 14, + punctuation = 15, + space = 16, + text = 17, + typeParameterName = 18, + enumMemberName = 19, + functionName = 20, + regularExpressionLiteral = 21, + } + interface SymbolDisplayPart { + text: string; + kind: string; + } + interface QuickInfo { + kind: string; + kindModifiers: string; + textSpan: TextSpan; + displayParts: SymbolDisplayPart[]; + documentation: SymbolDisplayPart[]; + } + interface RenameInfo { + canRename: boolean; + localizedErrorMessage: string; + displayName: string; + fullDisplayName: string; + kind: string; + kindModifiers: string; + triggerSpan: TextSpan; + } + interface SignatureHelpParameter { + name: string; + documentation: SymbolDisplayPart[]; + displayParts: SymbolDisplayPart[]; + isOptional: boolean; + } + /** + * Represents a single signature to show in signature help. + * The id is used for subsequent calls into the language service to ask questions about the + * signature help item in the context of any documents that have been updated. i.e. after + * an edit has happened, while signature help is still active, the host can ask important + * questions like 'what parameter is the user currently contained within?'. + */ + interface SignatureHelpItem { + isVariadic: boolean; + prefixDisplayParts: SymbolDisplayPart[]; + suffixDisplayParts: SymbolDisplayPart[]; + separatorDisplayParts: SymbolDisplayPart[]; + parameters: SignatureHelpParameter[]; + documentation: SymbolDisplayPart[]; + } + /** + * Represents a set of signature help items, and the preferred item that should be selected. + */ + interface SignatureHelpItems { + items: SignatureHelpItem[]; + applicableSpan: TextSpan; + selectedItemIndex: number; + argumentIndex: number; + argumentCount: number; + } + interface CompletionInfo { + isMemberCompletion: boolean; + entries: CompletionEntry[]; + } + interface CompletionEntry { + name: string; + kind: string; + kindModifiers: string; + } + interface CompletionEntryDetails { + name: string; + kind: string; + kindModifiers: string; + displayParts: SymbolDisplayPart[]; + documentation: SymbolDisplayPart[]; + } + interface OutliningSpan { + /** The span of the document to actually collapse. */ + textSpan: TextSpan; + /** The span of the document to display when the user hovers over the collapsed span. */ + hintSpan: TextSpan; + /** The text to display in the editor for the collapsed region. */ + bannerText: string; + /** + * Whether or not this region should be automatically collapsed when + * the 'Collapse to Definitions' command is invoked. + */ + autoCollapse: boolean; + } + interface EmitOutput { + outputFiles: OutputFile[]; + emitOutputStatus: EmitReturnStatus; + } + const enum OutputFileType { + JavaScript = 0, + SourceMap = 1, + Declaration = 2, + } + interface OutputFile { + name: string; + writeByteOrderMark: boolean; + text: string; + } + const enum EndOfLineState { + Start = 0, + InMultiLineCommentTrivia = 1, + InSingleQuoteStringLiteral = 2, + InDoubleQuoteStringLiteral = 3, + } + enum TokenClass { + Punctuation = 0, + Keyword = 1, + Operator = 2, + Comment = 3, + Whitespace = 4, + Identifier = 5, + NumberLiteral = 6, + StringLiteral = 7, + RegExpLiteral = 8, + } + interface ClassificationResult { + finalLexState: EndOfLineState; + entries: ClassificationInfo[]; + } + interface ClassificationInfo { + length: number; + classification: TokenClass; + } + interface Classifier { + getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult; + } + interface DocumentRegistry { + acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile; + updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; + releaseDocument(filename: string, compilationSettings: CompilerOptions): void; + } + class ScriptElementKind { + static unknown: string; + static keyword: string; + static scriptElement: string; + static moduleElement: string; + static classElement: string; + static interfaceElement: string; + static typeElement: string; + static enumElement: string; + static variableElement: string; + static localVariableElement: string; + static functionElement: string; + static localFunctionElement: string; + static memberFunctionElement: string; + static memberGetAccessorElement: string; + static memberSetAccessorElement: string; + static memberVariableElement: string; + static constructorImplementationElement: string; + static callSignatureElement: string; + static indexSignatureElement: string; + static constructSignatureElement: string; + static parameterElement: string; + static typeParameterElement: string; + static primitiveType: string; + static label: string; + static alias: string; + static constElement: string; + static letElement: string; + } + class ScriptElementKindModifier { + static none: string; + static publicMemberModifier: string; + static privateMemberModifier: string; + static protectedMemberModifier: string; + static exportedModifier: string; + static ambientModifier: string; + static staticModifier: string; + } + class ClassificationTypeNames { + static comment: string; + static identifier: string; + static keyword: string; + static numericLiteral: string; + static operator: string; + static stringLiteral: string; + static whiteSpace: string; + static text: string; + static punctuation: string; + static className: string; + static enumName: string; + static interfaceName: string; + static moduleName: string; + static typeParameterName: string; + } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; + interface DisplayPartsSymbolWriter extends SymbolWriter { + displayParts(): SymbolDisplayPart[]; + } + function getDefaultCompilerOptions(): CompilerOptions; + class OperationCanceledException { + } + class CancellationTokenObject { + private cancellationToken; + static None: CancellationTokenObject; + constructor(cancellationToken: CancellationToken); + isCancellationRequested(): boolean; + throwIfCancellationRequested(): void; + } + function createDocumentRegistry(): DocumentRegistry; + function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; + function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService; + function createClassifier(host: Logger): Classifier; +} + +export = ts; + +//// [APISample_node_compile.js] +var ts = require("typescript"); +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", 2 /* Latest */, "0.0"); +var program = ts.createProgram(["file1.ts"], {}, undefined); diff --git a/tests/baselines/reference/APISample_node_compile.types b/tests/baselines/reference/APISample_node_compile.types new file mode 100644 index 0000000000000..15aa4b13a2e01 --- /dev/null +++ b/tests/baselines/reference/APISample_node_compile.types @@ -0,0 +1,5647 @@ +=== tests/cases/compiler/APISample_node_compile.ts === + +import ts = require("typescript"); +>ts : typeof ts + +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0"); +>sourceFile : ts.SourceFile +>ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0") : ts.SourceFile +>ts.createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile +>ts : typeof ts +>createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile +>ts.ScriptTarget.Latest : ts.ScriptTarget +>ts.ScriptTarget : typeof ts.ScriptTarget +>ts : typeof ts +>ScriptTarget : typeof ts.ScriptTarget +>Latest : ts.ScriptTarget + +var program = ts.createProgram(["file1.ts"], {}, undefined); +>program : ts.Program +>ts.createProgram(["file1.ts"], {}, undefined) : ts.Program +>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program +>ts : typeof ts +>createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program +>["file1.ts"] : string[] +>{} : { [x: string]: undefined; } +>undefined : undefined + +=== typescript.d.ts === +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +declare module ts { +>ts : typeof ts + + interface Map { +>Map : Map +>T : T + + [index: string]: T; +>index : string +>T : T + } + interface TextRange { +>TextRange : TextRange + + pos: number; +>pos : number + + end: number; +>end : number + } + const enum SyntaxKind { +>SyntaxKind : SyntaxKind + + Unknown = 0, +>Unknown : SyntaxKind + + EndOfFileToken = 1, +>EndOfFileToken : SyntaxKind + + SingleLineCommentTrivia = 2, +>SingleLineCommentTrivia : SyntaxKind + + MultiLineCommentTrivia = 3, +>MultiLineCommentTrivia : SyntaxKind + + NewLineTrivia = 4, +>NewLineTrivia : SyntaxKind + + WhitespaceTrivia = 5, +>WhitespaceTrivia : SyntaxKind + + NumericLiteral = 6, +>NumericLiteral : SyntaxKind + + StringLiteral = 7, +>StringLiteral : SyntaxKind + + RegularExpressionLiteral = 8, +>RegularExpressionLiteral : SyntaxKind + + NoSubstitutionTemplateLiteral = 9, +>NoSubstitutionTemplateLiteral : SyntaxKind + + TemplateHead = 10, +>TemplateHead : SyntaxKind + + TemplateMiddle = 11, +>TemplateMiddle : SyntaxKind + + TemplateTail = 12, +>TemplateTail : SyntaxKind + + OpenBraceToken = 13, +>OpenBraceToken : SyntaxKind + + CloseBraceToken = 14, +>CloseBraceToken : SyntaxKind + + OpenParenToken = 15, +>OpenParenToken : SyntaxKind + + CloseParenToken = 16, +>CloseParenToken : SyntaxKind + + OpenBracketToken = 17, +>OpenBracketToken : SyntaxKind + + CloseBracketToken = 18, +>CloseBracketToken : SyntaxKind + + DotToken = 19, +>DotToken : SyntaxKind + + DotDotDotToken = 20, +>DotDotDotToken : SyntaxKind + + SemicolonToken = 21, +>SemicolonToken : SyntaxKind + + CommaToken = 22, +>CommaToken : SyntaxKind + + LessThanToken = 23, +>LessThanToken : SyntaxKind + + GreaterThanToken = 24, +>GreaterThanToken : SyntaxKind + + LessThanEqualsToken = 25, +>LessThanEqualsToken : SyntaxKind + + GreaterThanEqualsToken = 26, +>GreaterThanEqualsToken : SyntaxKind + + EqualsEqualsToken = 27, +>EqualsEqualsToken : SyntaxKind + + ExclamationEqualsToken = 28, +>ExclamationEqualsToken : SyntaxKind + + EqualsEqualsEqualsToken = 29, +>EqualsEqualsEqualsToken : SyntaxKind + + ExclamationEqualsEqualsToken = 30, +>ExclamationEqualsEqualsToken : SyntaxKind + + EqualsGreaterThanToken = 31, +>EqualsGreaterThanToken : SyntaxKind + + PlusToken = 32, +>PlusToken : SyntaxKind + + MinusToken = 33, +>MinusToken : SyntaxKind + + AsteriskToken = 34, +>AsteriskToken : SyntaxKind + + SlashToken = 35, +>SlashToken : SyntaxKind + + PercentToken = 36, +>PercentToken : SyntaxKind + + PlusPlusToken = 37, +>PlusPlusToken : SyntaxKind + + MinusMinusToken = 38, +>MinusMinusToken : SyntaxKind + + LessThanLessThanToken = 39, +>LessThanLessThanToken : SyntaxKind + + GreaterThanGreaterThanToken = 40, +>GreaterThanGreaterThanToken : SyntaxKind + + GreaterThanGreaterThanGreaterThanToken = 41, +>GreaterThanGreaterThanGreaterThanToken : SyntaxKind + + AmpersandToken = 42, +>AmpersandToken : SyntaxKind + + BarToken = 43, +>BarToken : SyntaxKind + + CaretToken = 44, +>CaretToken : SyntaxKind + + ExclamationToken = 45, +>ExclamationToken : SyntaxKind + + TildeToken = 46, +>TildeToken : SyntaxKind + + AmpersandAmpersandToken = 47, +>AmpersandAmpersandToken : SyntaxKind + + BarBarToken = 48, +>BarBarToken : SyntaxKind + + QuestionToken = 49, +>QuestionToken : SyntaxKind + + ColonToken = 50, +>ColonToken : SyntaxKind + + EqualsToken = 51, +>EqualsToken : SyntaxKind + + PlusEqualsToken = 52, +>PlusEqualsToken : SyntaxKind + + MinusEqualsToken = 53, +>MinusEqualsToken : SyntaxKind + + AsteriskEqualsToken = 54, +>AsteriskEqualsToken : SyntaxKind + + SlashEqualsToken = 55, +>SlashEqualsToken : SyntaxKind + + PercentEqualsToken = 56, +>PercentEqualsToken : SyntaxKind + + LessThanLessThanEqualsToken = 57, +>LessThanLessThanEqualsToken : SyntaxKind + + GreaterThanGreaterThanEqualsToken = 58, +>GreaterThanGreaterThanEqualsToken : SyntaxKind + + GreaterThanGreaterThanGreaterThanEqualsToken = 59, +>GreaterThanGreaterThanGreaterThanEqualsToken : SyntaxKind + + AmpersandEqualsToken = 60, +>AmpersandEqualsToken : SyntaxKind + + BarEqualsToken = 61, +>BarEqualsToken : SyntaxKind + + CaretEqualsToken = 62, +>CaretEqualsToken : SyntaxKind + + Identifier = 63, +>Identifier : SyntaxKind + + BreakKeyword = 64, +>BreakKeyword : SyntaxKind + + CaseKeyword = 65, +>CaseKeyword : SyntaxKind + + CatchKeyword = 66, +>CatchKeyword : SyntaxKind + + ClassKeyword = 67, +>ClassKeyword : SyntaxKind + + ConstKeyword = 68, +>ConstKeyword : SyntaxKind + + ContinueKeyword = 69, +>ContinueKeyword : SyntaxKind + + DebuggerKeyword = 70, +>DebuggerKeyword : SyntaxKind + + DefaultKeyword = 71, +>DefaultKeyword : SyntaxKind + + DeleteKeyword = 72, +>DeleteKeyword : SyntaxKind + + DoKeyword = 73, +>DoKeyword : SyntaxKind + + ElseKeyword = 74, +>ElseKeyword : SyntaxKind + + EnumKeyword = 75, +>EnumKeyword : SyntaxKind + + ExportKeyword = 76, +>ExportKeyword : SyntaxKind + + ExtendsKeyword = 77, +>ExtendsKeyword : SyntaxKind + + FalseKeyword = 78, +>FalseKeyword : SyntaxKind + + FinallyKeyword = 79, +>FinallyKeyword : SyntaxKind + + ForKeyword = 80, +>ForKeyword : SyntaxKind + + FunctionKeyword = 81, +>FunctionKeyword : SyntaxKind + + IfKeyword = 82, +>IfKeyword : SyntaxKind + + ImportKeyword = 83, +>ImportKeyword : SyntaxKind + + InKeyword = 84, +>InKeyword : SyntaxKind + + InstanceOfKeyword = 85, +>InstanceOfKeyword : SyntaxKind + + NewKeyword = 86, +>NewKeyword : SyntaxKind + + NullKeyword = 87, +>NullKeyword : SyntaxKind + + ReturnKeyword = 88, +>ReturnKeyword : SyntaxKind + + SuperKeyword = 89, +>SuperKeyword : SyntaxKind + + SwitchKeyword = 90, +>SwitchKeyword : SyntaxKind + + ThisKeyword = 91, +>ThisKeyword : SyntaxKind + + ThrowKeyword = 92, +>ThrowKeyword : SyntaxKind + + TrueKeyword = 93, +>TrueKeyword : SyntaxKind + + TryKeyword = 94, +>TryKeyword : SyntaxKind + + TypeOfKeyword = 95, +>TypeOfKeyword : SyntaxKind + + VarKeyword = 96, +>VarKeyword : SyntaxKind + + VoidKeyword = 97, +>VoidKeyword : SyntaxKind + + WhileKeyword = 98, +>WhileKeyword : SyntaxKind + + WithKeyword = 99, +>WithKeyword : SyntaxKind + + ImplementsKeyword = 100, +>ImplementsKeyword : SyntaxKind + + InterfaceKeyword = 101, +>InterfaceKeyword : SyntaxKind + + LetKeyword = 102, +>LetKeyword : SyntaxKind + + PackageKeyword = 103, +>PackageKeyword : SyntaxKind + + PrivateKeyword = 104, +>PrivateKeyword : SyntaxKind + + ProtectedKeyword = 105, +>ProtectedKeyword : SyntaxKind + + PublicKeyword = 106, +>PublicKeyword : SyntaxKind + + StaticKeyword = 107, +>StaticKeyword : SyntaxKind + + YieldKeyword = 108, +>YieldKeyword : SyntaxKind + + AnyKeyword = 109, +>AnyKeyword : SyntaxKind + + BooleanKeyword = 110, +>BooleanKeyword : SyntaxKind + + ConstructorKeyword = 111, +>ConstructorKeyword : SyntaxKind + + DeclareKeyword = 112, +>DeclareKeyword : SyntaxKind + + GetKeyword = 113, +>GetKeyword : SyntaxKind + + ModuleKeyword = 114, +>ModuleKeyword : SyntaxKind + + RequireKeyword = 115, +>RequireKeyword : SyntaxKind + + NumberKeyword = 116, +>NumberKeyword : SyntaxKind + + SetKeyword = 117, +>SetKeyword : SyntaxKind + + StringKeyword = 118, +>StringKeyword : SyntaxKind + + TypeKeyword = 119, +>TypeKeyword : SyntaxKind + + Missing = 120, +>Missing : SyntaxKind + + QualifiedName = 121, +>QualifiedName : SyntaxKind + + ComputedPropertyName = 122, +>ComputedPropertyName : SyntaxKind + + TypeParameter = 123, +>TypeParameter : SyntaxKind + + Parameter = 124, +>Parameter : SyntaxKind + + Property = 125, +>Property : SyntaxKind + + Method = 126, +>Method : SyntaxKind + + Constructor = 127, +>Constructor : SyntaxKind + + GetAccessor = 128, +>GetAccessor : SyntaxKind + + SetAccessor = 129, +>SetAccessor : SyntaxKind + + CallSignature = 130, +>CallSignature : SyntaxKind + + ConstructSignature = 131, +>ConstructSignature : SyntaxKind + + IndexSignature = 132, +>IndexSignature : SyntaxKind + + TypeReference = 133, +>TypeReference : SyntaxKind + + FunctionType = 134, +>FunctionType : SyntaxKind + + ConstructorType = 135, +>ConstructorType : SyntaxKind + + TypeQuery = 136, +>TypeQuery : SyntaxKind + + TypeLiteral = 137, +>TypeLiteral : SyntaxKind + + ArrayType = 138, +>ArrayType : SyntaxKind + + TupleType = 139, +>TupleType : SyntaxKind + + UnionType = 140, +>UnionType : SyntaxKind + + ParenthesizedType = 141, +>ParenthesizedType : SyntaxKind + + ArrayLiteralExpression = 142, +>ArrayLiteralExpression : SyntaxKind + + ObjectLiteralExpression = 143, +>ObjectLiteralExpression : SyntaxKind + + PropertyAccessExpression = 144, +>PropertyAccessExpression : SyntaxKind + + ElementAccessExpression = 145, +>ElementAccessExpression : SyntaxKind + + CallExpression = 146, +>CallExpression : SyntaxKind + + NewExpression = 147, +>NewExpression : SyntaxKind + + TaggedTemplateExpression = 148, +>TaggedTemplateExpression : SyntaxKind + + TypeAssertionExpression = 149, +>TypeAssertionExpression : SyntaxKind + + ParenthesizedExpression = 150, +>ParenthesizedExpression : SyntaxKind + + FunctionExpression = 151, +>FunctionExpression : SyntaxKind + + ArrowFunction = 152, +>ArrowFunction : SyntaxKind + + DeleteExpression = 153, +>DeleteExpression : SyntaxKind + + TypeOfExpression = 154, +>TypeOfExpression : SyntaxKind + + VoidExpression = 155, +>VoidExpression : SyntaxKind + + PrefixUnaryExpression = 156, +>PrefixUnaryExpression : SyntaxKind + + PostfixUnaryExpression = 157, +>PostfixUnaryExpression : SyntaxKind + + BinaryExpression = 158, +>BinaryExpression : SyntaxKind + + ConditionalExpression = 159, +>ConditionalExpression : SyntaxKind + + TemplateExpression = 160, +>TemplateExpression : SyntaxKind + + YieldExpression = 161, +>YieldExpression : SyntaxKind + + OmittedExpression = 162, +>OmittedExpression : SyntaxKind + + TemplateSpan = 163, +>TemplateSpan : SyntaxKind + + Block = 164, +>Block : SyntaxKind + + VariableStatement = 165, +>VariableStatement : SyntaxKind + + EmptyStatement = 166, +>EmptyStatement : SyntaxKind + + ExpressionStatement = 167, +>ExpressionStatement : SyntaxKind + + IfStatement = 168, +>IfStatement : SyntaxKind + + DoStatement = 169, +>DoStatement : SyntaxKind + + WhileStatement = 170, +>WhileStatement : SyntaxKind + + ForStatement = 171, +>ForStatement : SyntaxKind + + ForInStatement = 172, +>ForInStatement : SyntaxKind + + ContinueStatement = 173, +>ContinueStatement : SyntaxKind + + BreakStatement = 174, +>BreakStatement : SyntaxKind + + ReturnStatement = 175, +>ReturnStatement : SyntaxKind + + WithStatement = 176, +>WithStatement : SyntaxKind + + SwitchStatement = 177, +>SwitchStatement : SyntaxKind + + LabeledStatement = 178, +>LabeledStatement : SyntaxKind + + ThrowStatement = 179, +>ThrowStatement : SyntaxKind + + TryStatement = 180, +>TryStatement : SyntaxKind + + TryBlock = 181, +>TryBlock : SyntaxKind + + CatchBlock = 182, +>CatchBlock : SyntaxKind + + FinallyBlock = 183, +>FinallyBlock : SyntaxKind + + DebuggerStatement = 184, +>DebuggerStatement : SyntaxKind + + VariableDeclaration = 185, +>VariableDeclaration : SyntaxKind + + FunctionDeclaration = 186, +>FunctionDeclaration : SyntaxKind + + FunctionBlock = 187, +>FunctionBlock : SyntaxKind + + ClassDeclaration = 188, +>ClassDeclaration : SyntaxKind + + InterfaceDeclaration = 189, +>InterfaceDeclaration : SyntaxKind + + TypeAliasDeclaration = 190, +>TypeAliasDeclaration : SyntaxKind + + EnumDeclaration = 191, +>EnumDeclaration : SyntaxKind + + ModuleDeclaration = 192, +>ModuleDeclaration : SyntaxKind + + ModuleBlock = 193, +>ModuleBlock : SyntaxKind + + ImportDeclaration = 194, +>ImportDeclaration : SyntaxKind + + ExportAssignment = 195, +>ExportAssignment : SyntaxKind + + CaseClause = 196, +>CaseClause : SyntaxKind + + DefaultClause = 197, +>DefaultClause : SyntaxKind + + HeritageClause = 198, +>HeritageClause : SyntaxKind + + PropertyAssignment = 199, +>PropertyAssignment : SyntaxKind + + ShorthandPropertyAssignment = 200, +>ShorthandPropertyAssignment : SyntaxKind + + EnumMember = 201, +>EnumMember : SyntaxKind + + SourceFile = 202, +>SourceFile : SyntaxKind + + Program = 203, +>Program : SyntaxKind + + SyntaxList = 204, +>SyntaxList : SyntaxKind + + Count = 205, +>Count : SyntaxKind + + FirstAssignment = 51, +>FirstAssignment : SyntaxKind + + LastAssignment = 62, +>LastAssignment : SyntaxKind + + FirstReservedWord = 64, +>FirstReservedWord : SyntaxKind + + LastReservedWord = 99, +>LastReservedWord : SyntaxKind + + FirstKeyword = 64, +>FirstKeyword : SyntaxKind + + LastKeyword = 119, +>LastKeyword : SyntaxKind + + FirstFutureReservedWord = 100, +>FirstFutureReservedWord : SyntaxKind + + LastFutureReservedWord = 108, +>LastFutureReservedWord : SyntaxKind + + FirstTypeNode = 133, +>FirstTypeNode : SyntaxKind + + LastTypeNode = 141, +>LastTypeNode : SyntaxKind + + FirstPunctuation = 13, +>FirstPunctuation : SyntaxKind + + LastPunctuation = 62, +>LastPunctuation : SyntaxKind + + FirstToken = 1, +>FirstToken : SyntaxKind + + LastToken = 119, +>LastToken : SyntaxKind + + FirstTriviaToken = 2, +>FirstTriviaToken : SyntaxKind + + LastTriviaToken = 5, +>LastTriviaToken : SyntaxKind + + FirstLiteralToken = 6, +>FirstLiteralToken : SyntaxKind + + LastLiteralToken = 9, +>LastLiteralToken : SyntaxKind + + FirstTemplateToken = 9, +>FirstTemplateToken : SyntaxKind + + LastTemplateToken = 12, +>LastTemplateToken : SyntaxKind + + FirstOperator = 21, +>FirstOperator : SyntaxKind + + LastOperator = 62, +>LastOperator : SyntaxKind + + FirstBinaryOperator = 23, +>FirstBinaryOperator : SyntaxKind + + LastBinaryOperator = 62, +>LastBinaryOperator : SyntaxKind + } + const enum NodeFlags { +>NodeFlags : NodeFlags + + Export = 1, +>Export : NodeFlags + + Ambient = 2, +>Ambient : NodeFlags + + QuestionMark = 4, +>QuestionMark : NodeFlags + + Rest = 8, +>Rest : NodeFlags + + Public = 16, +>Public : NodeFlags + + Private = 32, +>Private : NodeFlags + + Protected = 64, +>Protected : NodeFlags + + Static = 128, +>Static : NodeFlags + + MultiLine = 256, +>MultiLine : NodeFlags + + Synthetic = 512, +>Synthetic : NodeFlags + + DeclarationFile = 1024, +>DeclarationFile : NodeFlags + + Let = 2048, +>Let : NodeFlags + + Const = 4096, +>Const : NodeFlags + + OctalLiteral = 8192, +>OctalLiteral : NodeFlags + + Modifier = 243, +>Modifier : NodeFlags + + AccessibilityModifier = 112, +>AccessibilityModifier : NodeFlags + + BlockScoped = 6144, +>BlockScoped : NodeFlags + } + const enum ParserContextFlags { +>ParserContextFlags : ParserContextFlags + + StrictMode = 1, +>StrictMode : ParserContextFlags + + DisallowIn = 2, +>DisallowIn : ParserContextFlags + + Yield = 4, +>Yield : ParserContextFlags + + GeneratorParameter = 8, +>GeneratorParameter : ParserContextFlags + } + interface Node extends TextRange { +>Node : Node +>TextRange : TextRange + + kind: SyntaxKind; +>kind : SyntaxKind +>SyntaxKind : SyntaxKind + + flags: NodeFlags; +>flags : NodeFlags +>NodeFlags : NodeFlags + + parserContextFlags?: ParserContextFlags; +>parserContextFlags : ParserContextFlags +>ParserContextFlags : ParserContextFlags + + id?: number; +>id : number + + parent?: Node; +>parent : Node +>Node : Node + + symbol?: Symbol; +>symbol : Symbol +>Symbol : Symbol + + locals?: SymbolTable; +>locals : SymbolTable +>SymbolTable : SymbolTable + + nextContainer?: Node; +>nextContainer : Node +>Node : Node + + localSymbol?: Symbol; +>localSymbol : Symbol +>Symbol : Symbol + + modifiers?: ModifiersArray; +>modifiers : ModifiersArray +>ModifiersArray : ModifiersArray + } + interface NodeArray extends Array, TextRange { +>NodeArray : NodeArray +>T : T +>Array : T[] +>T : T +>TextRange : TextRange + + hasTrailingComma?: boolean; +>hasTrailingComma : boolean + } + interface ModifiersArray extends Array { +>ModifiersArray : ModifiersArray +>Array : T[] +>Node : Node + + flags: number; +>flags : number + } + interface Identifier extends PrimaryExpression { +>Identifier : Identifier +>PrimaryExpression : PrimaryExpression + + text: string; +>text : string + } + interface QualifiedName extends Node { +>QualifiedName : QualifiedName +>Node : Node + + left: EntityName; +>left : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + + right: Identifier; +>right : Identifier +>Identifier : Identifier + } + type EntityName = Identifier | QualifiedName; +>EntityName : Identifier | QualifiedName +>Identifier : Identifier +>QualifiedName : QualifiedName + + interface ParsedSignature { +>ParsedSignature : ParsedSignature + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + parameters: NodeArray; +>parameters : NodeArray +>NodeArray : NodeArray +>ParameterDeclaration : ParameterDeclaration + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName +>Identifier : Identifier +>LiteralExpression : LiteralExpression +>ComputedPropertyName : ComputedPropertyName + + interface Declaration extends Node { +>Declaration : Declaration +>Node : Node + + _declarationBrand: any; +>_declarationBrand : any + + name?: DeclarationName; +>name : Identifier | LiteralExpression | ComputedPropertyName +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName + } + interface ComputedPropertyName extends Node { +>ComputedPropertyName : ComputedPropertyName +>Node : Node + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface TypeParameterDeclaration extends Declaration { +>TypeParameterDeclaration : TypeParameterDeclaration +>Declaration : Declaration + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + constraint?: TypeNode; +>constraint : TypeNode +>TypeNode : TypeNode + + expression?: Expression; +>expression : Expression +>Expression : Expression + } + interface SignatureDeclaration extends Declaration, ParsedSignature { +>SignatureDeclaration : SignatureDeclaration +>Declaration : Declaration +>ParsedSignature : ParsedSignature + } + interface VariableDeclaration extends Declaration { +>VariableDeclaration : VariableDeclaration +>Declaration : Declaration + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + } + interface PropertyDeclaration extends Declaration, ClassElement { +>PropertyDeclaration : PropertyDeclaration +>Declaration : Declaration +>ClassElement : ClassElement + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + } + interface ShortHandPropertyDeclaration extends Declaration { +>ShortHandPropertyDeclaration : ShortHandPropertyDeclaration +>Declaration : Declaration + + name: Identifier; +>name : Identifier +>Identifier : Identifier + } + interface ParameterDeclaration extends VariableDeclaration { +>ParameterDeclaration : ParameterDeclaration +>VariableDeclaration : VariableDeclaration + } + /** + * Several node kinds share function-like features such as a signature, + * a name, and a body. These nodes should extend FunctionLikeDeclaration. + * Examples: + * FunctionDeclaration + * MethodDeclaration + * AccessorDeclaration + */ + interface FunctionLikeDeclaration extends SignatureDeclaration { +>FunctionLikeDeclaration : FunctionLikeDeclaration +>SignatureDeclaration : SignatureDeclaration + + _functionLikeDeclarationBrand: any; +>_functionLikeDeclarationBrand : any + + asteriskToken?: Node; +>asteriskToken : Node +>Node : Node + + body?: Block | Expression; +>body : Expression | Block +>Block : Block +>Expression : Expression + } + interface FunctionDeclaration extends FunctionLikeDeclaration, Statement { +>FunctionDeclaration : FunctionDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>Statement : Statement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + body?: Block; +>body : Block +>Block : Block + } + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { +>MethodDeclaration : MethodDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>ClassElement : ClassElement + + body?: Block; +>body : Block +>Block : Block + } + interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement { +>ConstructorDeclaration : ConstructorDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>ClassElement : ClassElement + + body?: Block; +>body : Block +>Block : Block + } + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { +>AccessorDeclaration : AccessorDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>ClassElement : ClassElement + + body?: Block; +>body : Block +>Block : Block + } + interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement { +>IndexSignatureDeclaration : IndexSignatureDeclaration +>SignatureDeclaration : SignatureDeclaration +>ClassElement : ClassElement + + _indexSignatureDeclarationBrand: any; +>_indexSignatureDeclarationBrand : any + } + interface TypeNode extends Node { +>TypeNode : TypeNode +>Node : Node + } + interface TypeReferenceNode extends TypeNode { +>TypeReferenceNode : TypeReferenceNode +>TypeNode : TypeNode + + typeName: EntityName; +>typeName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + + typeArguments?: NodeArray; +>typeArguments : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + } + interface TypeQueryNode extends TypeNode { +>TypeQueryNode : TypeQueryNode +>TypeNode : TypeNode + + exprName: EntityName; +>exprName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + } + interface TypeLiteralNode extends TypeNode, Declaration { +>TypeLiteralNode : TypeLiteralNode +>TypeNode : TypeNode +>Declaration : Declaration + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>Node : Node + } + interface ArrayTypeNode extends TypeNode { +>ArrayTypeNode : ArrayTypeNode +>TypeNode : TypeNode + + elementType: TypeNode; +>elementType : TypeNode +>TypeNode : TypeNode + } + interface TupleTypeNode extends TypeNode { +>TupleTypeNode : TupleTypeNode +>TypeNode : TypeNode + + elementTypes: NodeArray; +>elementTypes : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + } + interface UnionTypeNode extends TypeNode { +>UnionTypeNode : UnionTypeNode +>TypeNode : TypeNode + + types: NodeArray; +>types : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + } + interface ParenthesizedTypeNode extends TypeNode { +>ParenthesizedTypeNode : ParenthesizedTypeNode +>TypeNode : TypeNode + + type: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + interface StringLiteralTypeNode extends TypeNode { +>StringLiteralTypeNode : StringLiteralTypeNode +>TypeNode : TypeNode + + text: string; +>text : string + } + interface Expression extends Node { +>Expression : Expression +>Node : Node + + _expressionBrand: any; +>_expressionBrand : any + + contextualType?: Type; +>contextualType : Type +>Type : Type + } + interface UnaryExpression extends Expression { +>UnaryExpression : UnaryExpression +>Expression : Expression + + _unaryExpressionBrand: any; +>_unaryExpressionBrand : any + } + interface PrefixUnaryExpression extends UnaryExpression { +>PrefixUnaryExpression : PrefixUnaryExpression +>UnaryExpression : UnaryExpression + + operator: SyntaxKind; +>operator : SyntaxKind +>SyntaxKind : SyntaxKind + + operand: UnaryExpression; +>operand : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface PostfixUnaryExpression extends PostfixExpression { +>PostfixUnaryExpression : PostfixUnaryExpression +>PostfixExpression : PostfixExpression + + operand: LeftHandSideExpression; +>operand : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + operator: SyntaxKind; +>operator : SyntaxKind +>SyntaxKind : SyntaxKind + } + interface PostfixExpression extends UnaryExpression { +>PostfixExpression : PostfixExpression +>UnaryExpression : UnaryExpression + + _postfixExpressionBrand: any; +>_postfixExpressionBrand : any + } + interface LeftHandSideExpression extends PostfixExpression { +>LeftHandSideExpression : LeftHandSideExpression +>PostfixExpression : PostfixExpression + + _leftHandSideExpressionBrand: any; +>_leftHandSideExpressionBrand : any + } + interface MemberExpression extends LeftHandSideExpression { +>MemberExpression : MemberExpression +>LeftHandSideExpression : LeftHandSideExpression + + _memberExpressionBrand: any; +>_memberExpressionBrand : any + } + interface PrimaryExpression extends MemberExpression { +>PrimaryExpression : PrimaryExpression +>MemberExpression : MemberExpression + + _primaryExpressionBrand: any; +>_primaryExpressionBrand : any + } + interface DeleteExpression extends UnaryExpression { +>DeleteExpression : DeleteExpression +>UnaryExpression : UnaryExpression + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface TypeOfExpression extends UnaryExpression { +>TypeOfExpression : TypeOfExpression +>UnaryExpression : UnaryExpression + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface VoidExpression extends UnaryExpression { +>VoidExpression : VoidExpression +>UnaryExpression : UnaryExpression + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface YieldExpression extends Expression { +>YieldExpression : YieldExpression +>Expression : Expression + + asteriskToken?: Node; +>asteriskToken : Node +>Node : Node + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface BinaryExpression extends Expression { +>BinaryExpression : BinaryExpression +>Expression : Expression + + left: Expression; +>left : Expression +>Expression : Expression + + operator: SyntaxKind; +>operator : SyntaxKind +>SyntaxKind : SyntaxKind + + right: Expression; +>right : Expression +>Expression : Expression + } + interface ConditionalExpression extends Expression { +>ConditionalExpression : ConditionalExpression +>Expression : Expression + + condition: Expression; +>condition : Expression +>Expression : Expression + + whenTrue: Expression; +>whenTrue : Expression +>Expression : Expression + + whenFalse: Expression; +>whenFalse : Expression +>Expression : Expression + } + interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration { +>FunctionExpression : FunctionExpression +>PrimaryExpression : PrimaryExpression +>FunctionLikeDeclaration : FunctionLikeDeclaration + + name?: Identifier; +>name : Identifier +>Identifier : Identifier + + body: Block | Expression; +>body : Expression | Block +>Block : Block +>Expression : Expression + } + interface LiteralExpression extends PrimaryExpression { +>LiteralExpression : LiteralExpression +>PrimaryExpression : PrimaryExpression + + text: string; +>text : string + } + interface TemplateExpression extends PrimaryExpression { +>TemplateExpression : TemplateExpression +>PrimaryExpression : PrimaryExpression + + head: LiteralExpression; +>head : LiteralExpression +>LiteralExpression : LiteralExpression + + templateSpans: NodeArray; +>templateSpans : NodeArray +>NodeArray : NodeArray +>TemplateSpan : TemplateSpan + } + interface TemplateSpan extends Node { +>TemplateSpan : TemplateSpan +>Node : Node + + expression: Expression; +>expression : Expression +>Expression : Expression + + literal: LiteralExpression; +>literal : LiteralExpression +>LiteralExpression : LiteralExpression + } + interface ParenthesizedExpression extends PrimaryExpression { +>ParenthesizedExpression : ParenthesizedExpression +>PrimaryExpression : PrimaryExpression + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface ArrayLiteralExpression extends PrimaryExpression { +>ArrayLiteralExpression : ArrayLiteralExpression +>PrimaryExpression : PrimaryExpression + + elements: NodeArray; +>elements : NodeArray +>NodeArray : NodeArray +>Expression : Expression + } + interface ObjectLiteralExpression extends PrimaryExpression, Declaration { +>ObjectLiteralExpression : ObjectLiteralExpression +>PrimaryExpression : PrimaryExpression +>Declaration : Declaration + + properties: NodeArray; +>properties : NodeArray +>NodeArray : NodeArray +>Declaration : Declaration + } + interface PropertyAccessExpression extends MemberExpression { +>PropertyAccessExpression : PropertyAccessExpression +>MemberExpression : MemberExpression + + expression: LeftHandSideExpression; +>expression : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + name: Identifier; +>name : Identifier +>Identifier : Identifier + } + interface ElementAccessExpression extends MemberExpression { +>ElementAccessExpression : ElementAccessExpression +>MemberExpression : MemberExpression + + expression: LeftHandSideExpression; +>expression : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + argumentExpression: Expression; +>argumentExpression : Expression +>Expression : Expression + } + interface CallExpression extends LeftHandSideExpression { +>CallExpression : CallExpression +>LeftHandSideExpression : LeftHandSideExpression + + expression: LeftHandSideExpression; +>expression : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + typeArguments?: NodeArray; +>typeArguments : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + + arguments: NodeArray; +>arguments : NodeArray +>NodeArray : NodeArray +>Expression : Expression + } + interface NewExpression extends CallExpression, PrimaryExpression { +>NewExpression : NewExpression +>CallExpression : CallExpression +>PrimaryExpression : PrimaryExpression + } + interface TaggedTemplateExpression extends MemberExpression { +>TaggedTemplateExpression : TaggedTemplateExpression +>MemberExpression : MemberExpression + + tag: LeftHandSideExpression; +>tag : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + template: LiteralExpression | TemplateExpression; +>template : LiteralExpression | TemplateExpression +>LiteralExpression : LiteralExpression +>TemplateExpression : TemplateExpression + } + type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; +>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression +>CallExpression : CallExpression +>NewExpression : NewExpression +>TaggedTemplateExpression : TaggedTemplateExpression + + interface TypeAssertion extends UnaryExpression { +>TypeAssertion : TypeAssertion +>UnaryExpression : UnaryExpression + + type: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface Statement extends Node, ModuleElement { +>Statement : Statement +>Node : Node +>ModuleElement : ModuleElement + + _statementBrand: any; +>_statementBrand : any + } + interface Block extends Statement { +>Block : Block +>Statement : Statement + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>Statement : Statement + } + interface VariableStatement extends Statement { +>VariableStatement : VariableStatement +>Statement : Statement + + declarations: NodeArray; +>declarations : NodeArray +>NodeArray : NodeArray +>VariableDeclaration : VariableDeclaration + } + interface ExpressionStatement extends Statement { +>ExpressionStatement : ExpressionStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface IfStatement extends Statement { +>IfStatement : IfStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + + thenStatement: Statement; +>thenStatement : Statement +>Statement : Statement + + elseStatement?: Statement; +>elseStatement : Statement +>Statement : Statement + } + interface IterationStatement extends Statement { +>IterationStatement : IterationStatement +>Statement : Statement + + statement: Statement; +>statement : Statement +>Statement : Statement + } + interface DoStatement extends IterationStatement { +>DoStatement : DoStatement +>IterationStatement : IterationStatement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface WhileStatement extends IterationStatement { +>WhileStatement : WhileStatement +>IterationStatement : IterationStatement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface ForStatement extends IterationStatement { +>ForStatement : ForStatement +>IterationStatement : IterationStatement + + declarations?: NodeArray; +>declarations : NodeArray +>NodeArray : NodeArray +>VariableDeclaration : VariableDeclaration + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + + condition?: Expression; +>condition : Expression +>Expression : Expression + + iterator?: Expression; +>iterator : Expression +>Expression : Expression + } + interface ForInStatement extends IterationStatement { +>ForInStatement : ForInStatement +>IterationStatement : IterationStatement + + declarations?: NodeArray; +>declarations : NodeArray +>NodeArray : NodeArray +>VariableDeclaration : VariableDeclaration + + variable?: Expression; +>variable : Expression +>Expression : Expression + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface BreakOrContinueStatement extends Statement { +>BreakOrContinueStatement : BreakOrContinueStatement +>Statement : Statement + + label?: Identifier; +>label : Identifier +>Identifier : Identifier + } + interface ReturnStatement extends Statement { +>ReturnStatement : ReturnStatement +>Statement : Statement + + expression?: Expression; +>expression : Expression +>Expression : Expression + } + interface WithStatement extends Statement { +>WithStatement : WithStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + + statement: Statement; +>statement : Statement +>Statement : Statement + } + interface SwitchStatement extends Statement { +>SwitchStatement : SwitchStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + + clauses: NodeArray; +>clauses : NodeArray +>NodeArray : NodeArray +>CaseOrDefaultClause : CaseOrDefaultClause + } + interface CaseOrDefaultClause extends Node { +>CaseOrDefaultClause : CaseOrDefaultClause +>Node : Node + + expression?: Expression; +>expression : Expression +>Expression : Expression + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>Statement : Statement + } + interface LabeledStatement extends Statement { +>LabeledStatement : LabeledStatement +>Statement : Statement + + label: Identifier; +>label : Identifier +>Identifier : Identifier + + statement: Statement; +>statement : Statement +>Statement : Statement + } + interface ThrowStatement extends Statement { +>ThrowStatement : ThrowStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface TryStatement extends Statement { +>TryStatement : TryStatement +>Statement : Statement + + tryBlock: Block; +>tryBlock : Block +>Block : Block + + catchBlock?: CatchBlock; +>catchBlock : CatchBlock +>CatchBlock : CatchBlock + + finallyBlock?: Block; +>finallyBlock : Block +>Block : Block + } + interface CatchBlock extends Block, Declaration { +>CatchBlock : CatchBlock +>Block : Block +>Declaration : Declaration + + variable: Identifier; +>variable : Identifier +>Identifier : Identifier + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + interface ModuleElement extends Node { +>ModuleElement : ModuleElement +>Node : Node + + _moduleElementBrand: any; +>_moduleElementBrand : any + } + interface ClassDeclaration extends Declaration, ModuleElement { +>ClassDeclaration : ClassDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + heritageClauses?: NodeArray; +>heritageClauses : NodeArray +>NodeArray : NodeArray +>HeritageClause : HeritageClause + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>ClassElement : ClassElement + } + interface ClassElement extends Declaration { +>ClassElement : ClassElement +>Declaration : Declaration + + _classElementBrand: any; +>_classElementBrand : any + } + interface InterfaceDeclaration extends Declaration, ModuleElement { +>InterfaceDeclaration : InterfaceDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + heritageClauses?: NodeArray; +>heritageClauses : NodeArray +>NodeArray : NodeArray +>HeritageClause : HeritageClause + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>Declaration : Declaration + } + interface HeritageClause extends Node { +>HeritageClause : HeritageClause +>Node : Node + + token: SyntaxKind; +>token : SyntaxKind +>SyntaxKind : SyntaxKind + + types?: NodeArray; +>types : NodeArray +>NodeArray : NodeArray +>TypeReferenceNode : TypeReferenceNode + } + interface TypeAliasDeclaration extends Declaration, ModuleElement { +>TypeAliasDeclaration : TypeAliasDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + type: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + interface EnumMember extends Declaration { +>EnumMember : EnumMember +>Declaration : Declaration + + name: DeclarationName; +>name : Identifier | LiteralExpression | ComputedPropertyName +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + } + interface EnumDeclaration extends Declaration, ModuleElement { +>EnumDeclaration : EnumDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>EnumMember : EnumMember + } + interface ModuleDeclaration extends Declaration, ModuleElement { +>ModuleDeclaration : ModuleDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier | LiteralExpression; +>name : Identifier | LiteralExpression +>Identifier : Identifier +>LiteralExpression : LiteralExpression + + body: ModuleBlock | ModuleDeclaration; +>body : ModuleDeclaration | ModuleBlock +>ModuleBlock : ModuleBlock +>ModuleDeclaration : ModuleDeclaration + } + interface ModuleBlock extends Node, ModuleElement { +>ModuleBlock : ModuleBlock +>Node : Node +>ModuleElement : ModuleElement + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>ModuleElement : ModuleElement + } + interface ImportDeclaration extends Declaration, ModuleElement { +>ImportDeclaration : ImportDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + entityName?: EntityName; +>entityName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + + externalModuleName?: LiteralExpression; +>externalModuleName : LiteralExpression +>LiteralExpression : LiteralExpression + } + interface ExportAssignment extends Statement, ModuleElement { +>ExportAssignment : ExportAssignment +>Statement : Statement +>ModuleElement : ModuleElement + + exportName: Identifier; +>exportName : Identifier +>Identifier : Identifier + } + interface FileReference extends TextRange { +>FileReference : FileReference +>TextRange : TextRange + + filename: string; +>filename : string + } + interface CommentRange extends TextRange { +>CommentRange : CommentRange +>TextRange : TextRange + + hasTrailingNewLine?: boolean; +>hasTrailingNewLine : boolean + } + interface SourceFile extends Declaration { +>SourceFile : SourceFile +>Declaration : Declaration + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>ModuleElement : ModuleElement + + filename: string; +>filename : string + + text: string; +>text : string + + getLineAndCharacterFromPosition(position: number): LineAndCharacter; +>getLineAndCharacterFromPosition : (position: number) => LineAndCharacter +>position : number +>LineAndCharacter : LineAndCharacter + + getPositionFromLineAndCharacter(line: number, character: number): number; +>getPositionFromLineAndCharacter : (line: number, character: number) => number +>line : number +>character : number + + getLineStarts(): number[]; +>getLineStarts : () => number[] + + amdDependencies: string[]; +>amdDependencies : string[] + + amdModuleName: string; +>amdModuleName : string + + referencedFiles: FileReference[]; +>referencedFiles : FileReference[] +>FileReference : FileReference + + semanticDiagnostics: Diagnostic[]; +>semanticDiagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + parseDiagnostics: Diagnostic[]; +>parseDiagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + grammarDiagnostics: Diagnostic[]; +>grammarDiagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + getSyntacticDiagnostics(): Diagnostic[]; +>getSyntacticDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + hasNoDefaultLib: boolean; +>hasNoDefaultLib : boolean + + externalModuleIndicator: Node; +>externalModuleIndicator : Node +>Node : Node + + nodeCount: number; +>nodeCount : number + + identifierCount: number; +>identifierCount : number + + symbolCount: number; +>symbolCount : number + + isOpen: boolean; +>isOpen : boolean + + version: string; +>version : string + + languageVersion: ScriptTarget; +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget + + identifiers: Map; +>identifiers : Map +>Map : Map + } + interface Program { +>Program : Program + + getSourceFile(filename: string): SourceFile; +>getSourceFile : (filename: string) => SourceFile +>filename : string +>SourceFile : SourceFile + + getSourceFiles(): SourceFile[]; +>getSourceFiles : () => SourceFile[] +>SourceFile : SourceFile + + getCompilerOptions(): CompilerOptions; +>getCompilerOptions : () => CompilerOptions +>CompilerOptions : CompilerOptions + + getCompilerHost(): CompilerHost; +>getCompilerHost : () => CompilerHost +>CompilerHost : CompilerHost + + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; +>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Diagnostic : Diagnostic + + getGlobalDiagnostics(): Diagnostic[]; +>getGlobalDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + getTypeChecker(fullTypeCheckMode: boolean): TypeChecker; +>getTypeChecker : (fullTypeCheckMode: boolean) => TypeChecker +>fullTypeCheckMode : boolean +>TypeChecker : TypeChecker + + getCommonSourceDirectory(): string; +>getCommonSourceDirectory : () => string + } + interface SourceMapSpan { +>SourceMapSpan : SourceMapSpan + + emittedLine: number; +>emittedLine : number + + emittedColumn: number; +>emittedColumn : number + + sourceLine: number; +>sourceLine : number + + sourceColumn: number; +>sourceColumn : number + + nameIndex?: number; +>nameIndex : number + + sourceIndex: number; +>sourceIndex : number + } + interface SourceMapData { +>SourceMapData : SourceMapData + + sourceMapFilePath: string; +>sourceMapFilePath : string + + jsSourceMappingURL: string; +>jsSourceMappingURL : string + + sourceMapFile: string; +>sourceMapFile : string + + sourceMapSourceRoot: string; +>sourceMapSourceRoot : string + + sourceMapSources: string[]; +>sourceMapSources : string[] + + inputSourceFileNames: string[]; +>inputSourceFileNames : string[] + + sourceMapNames?: string[]; +>sourceMapNames : string[] + + sourceMapMappings: string; +>sourceMapMappings : string + + sourceMapDecodedMappings: SourceMapSpan[]; +>sourceMapDecodedMappings : SourceMapSpan[] +>SourceMapSpan : SourceMapSpan + } + enum EmitReturnStatus { +>EmitReturnStatus : EmitReturnStatus + + Succeeded = 0, +>Succeeded : EmitReturnStatus + + AllOutputGenerationSkipped = 1, +>AllOutputGenerationSkipped : EmitReturnStatus + + JSGeneratedWithSemanticErrors = 2, +>JSGeneratedWithSemanticErrors : EmitReturnStatus + + DeclarationGenerationSkipped = 3, +>DeclarationGenerationSkipped : EmitReturnStatus + + EmitErrorsEncountered = 4, +>EmitErrorsEncountered : EmitReturnStatus + + CompilerOptionsErrors = 5, +>CompilerOptionsErrors : EmitReturnStatus + } + interface EmitResult { +>EmitResult : EmitResult + + emitResultStatus: EmitReturnStatus; +>emitResultStatus : EmitReturnStatus +>EmitReturnStatus : EmitReturnStatus + + diagnostics: Diagnostic[]; +>diagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + sourceMaps: SourceMapData[]; +>sourceMaps : SourceMapData[] +>SourceMapData : SourceMapData + } + interface TypeChecker { +>TypeChecker : TypeChecker + + getProgram(): Program; +>getProgram : () => Program +>Program : Program + + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; +>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Diagnostic : Diagnostic + + getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[]; +>getDeclarationDiagnostics : (sourceFile: SourceFile) => Diagnostic[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Diagnostic : Diagnostic + + getGlobalDiagnostics(): Diagnostic[]; +>getGlobalDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + getNodeCount(): number; +>getNodeCount : () => number + + getIdentifierCount(): number; +>getIdentifierCount : () => number + + getSymbolCount(): number; +>getSymbolCount : () => number + + getTypeCount(): number; +>getTypeCount : () => number + + checkProgram(): void; +>checkProgram : () => void + + emitFiles(targetSourceFile?: SourceFile): EmitResult; +>emitFiles : (targetSourceFile?: SourceFile) => EmitResult +>targetSourceFile : SourceFile +>SourceFile : SourceFile +>EmitResult : EmitResult + + getParentOfSymbol(symbol: Symbol): Symbol; +>getParentOfSymbol : (symbol: Symbol) => Symbol +>symbol : Symbol +>Symbol : Symbol +>Symbol : Symbol + + getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; +>getNarrowedTypeOfSymbol : (symbol: Symbol, node: Node) => Type +>symbol : Symbol +>Symbol : Symbol +>node : Node +>Node : Node +>Type : Type + + getDeclaredTypeOfSymbol(symbol: Symbol): Type; +>getDeclaredTypeOfSymbol : (symbol: Symbol) => Type +>symbol : Symbol +>Symbol : Symbol +>Type : Type + + getPropertiesOfType(type: Type): Symbol[]; +>getPropertiesOfType : (type: Type) => Symbol[] +>type : Type +>Type : Type +>Symbol : Symbol + + getPropertyOfType(type: Type, propertyName: string): Symbol; +>getPropertyOfType : (type: Type, propertyName: string) => Symbol +>type : Type +>Type : Type +>propertyName : string +>Symbol : Symbol + + getSignaturesOfType(type: Type, kind: SignatureKind): Signature[]; +>getSignaturesOfType : (type: Type, kind: SignatureKind) => Signature[] +>type : Type +>Type : Type +>kind : SignatureKind +>SignatureKind : SignatureKind +>Signature : Signature + + getIndexTypeOfType(type: Type, kind: IndexKind): Type; +>getIndexTypeOfType : (type: Type, kind: IndexKind) => Type +>type : Type +>Type : Type +>kind : IndexKind +>IndexKind : IndexKind +>Type : Type + + getReturnTypeOfSignature(signature: Signature): Type; +>getReturnTypeOfSignature : (signature: Signature) => Type +>signature : Signature +>Signature : Signature +>Type : Type + + getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; +>getSymbolsInScope : (location: Node, meaning: SymbolFlags) => Symbol[] +>location : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags +>Symbol : Symbol + + getSymbolInfo(node: Node): Symbol; +>getSymbolInfo : (node: Node) => Symbol +>node : Node +>Node : Node +>Symbol : Symbol + + getShorthandAssignmentValueSymbol(location: Node): Symbol; +>getShorthandAssignmentValueSymbol : (location: Node) => Symbol +>location : Node +>Node : Node +>Symbol : Symbol + + getTypeOfNode(node: Node): Type; +>getTypeOfNode : (node: Node) => Type +>node : Node +>Node : Node +>Type : Type + + typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; +>typeToString : (type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => string +>type : Type +>Type : Type +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; +>symbolToString : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => string +>symbol : Symbol +>Symbol : Symbol +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags + + getSymbolDisplayBuilder(): SymbolDisplayBuilder; +>getSymbolDisplayBuilder : () => SymbolDisplayBuilder +>SymbolDisplayBuilder : SymbolDisplayBuilder + + getFullyQualifiedName(symbol: Symbol): string; +>getFullyQualifiedName : (symbol: Symbol) => string +>symbol : Symbol +>Symbol : Symbol + + getAugmentedPropertiesOfType(type: Type): Symbol[]; +>getAugmentedPropertiesOfType : (type: Type) => Symbol[] +>type : Type +>Type : Type +>Symbol : Symbol + + getRootSymbols(symbol: Symbol): Symbol[]; +>getRootSymbols : (symbol: Symbol) => Symbol[] +>symbol : Symbol +>Symbol : Symbol +>Symbol : Symbol + + getContextualType(node: Node): Type; +>getContextualType : (node: Node) => Type +>node : Node +>Node : Node +>Type : Type + + getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; +>getResolvedSignature : (node: CallExpression | NewExpression | TaggedTemplateExpression, candidatesOutArray?: Signature[]) => Signature +>node : CallExpression | NewExpression | TaggedTemplateExpression +>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression +>candidatesOutArray : Signature[] +>Signature : Signature +>Signature : Signature + + getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature; +>getSignatureFromDeclaration : (declaration: SignatureDeclaration) => Signature +>declaration : SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration +>Signature : Signature + + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; +>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean +>node : FunctionLikeDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration + + isUndefinedSymbol(symbol: Symbol): boolean; +>isUndefinedSymbol : (symbol: Symbol) => boolean +>symbol : Symbol +>Symbol : Symbol + + isArgumentsSymbol(symbol: Symbol): boolean; +>isArgumentsSymbol : (symbol: Symbol) => boolean +>symbol : Symbol +>Symbol : Symbol + + isEmitBlocked(sourceFile?: SourceFile): boolean; +>isEmitBlocked : (sourceFile?: SourceFile) => boolean +>sourceFile : SourceFile +>SourceFile : SourceFile + + getEnumMemberValue(node: EnumMember): number; +>getEnumMemberValue : (node: EnumMember) => number +>node : EnumMember +>EnumMember : EnumMember + + isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; +>isValidPropertyAccess : (node: QualifiedName | PropertyAccessExpression, propertyName: string) => boolean +>node : QualifiedName | PropertyAccessExpression +>PropertyAccessExpression : PropertyAccessExpression +>QualifiedName : QualifiedName +>propertyName : string + + getAliasedSymbol(symbol: Symbol): Symbol; +>getAliasedSymbol : (symbol: Symbol) => Symbol +>symbol : Symbol +>Symbol : Symbol +>Symbol : Symbol + } + interface SymbolDisplayBuilder { +>SymbolDisplayBuilder : SymbolDisplayBuilder + + buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildTypeDisplay : (type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>type : Type +>Type : Type +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void; +>buildSymbolDisplay : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags) => void +>symbol : Symbol +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags +>flags : SymbolFormatFlags +>SymbolFormatFlags : SymbolFormatFlags + + buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildSignatureDisplay : (signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>signatures : Signature +>Signature : Signature +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildParameterDisplay : (parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>parameter : Symbol +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildTypeParameterDisplay : (tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>tp : TypeParameter +>TypeParameter : TypeParameter +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void; +>buildTypeParameterDisplayFromSymbol : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags) => void +>symbol : Symbol +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaraiton : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildDisplayForParametersAndDelimiters : (parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>parameters : Symbol[] +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildDisplayForTypeParametersAndDelimiters : (typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildReturnTypeDisplay : (signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>signature : Signature +>Signature : Signature +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + } + interface SymbolWriter { +>SymbolWriter : SymbolWriter + + writeKeyword(text: string): void; +>writeKeyword : (text: string) => void +>text : string + + writeOperator(text: string): void; +>writeOperator : (text: string) => void +>text : string + + writePunctuation(text: string): void; +>writePunctuation : (text: string) => void +>text : string + + writeSpace(text: string): void; +>writeSpace : (text: string) => void +>text : string + + writeStringLiteral(text: string): void; +>writeStringLiteral : (text: string) => void +>text : string + + writeParameter(text: string): void; +>writeParameter : (text: string) => void +>text : string + + writeSymbol(text: string, symbol: Symbol): void; +>writeSymbol : (text: string, symbol: Symbol) => void +>text : string +>symbol : Symbol +>Symbol : Symbol + + writeLine(): void; +>writeLine : () => void + + increaseIndent(): void; +>increaseIndent : () => void + + decreaseIndent(): void; +>decreaseIndent : () => void + + clear(): void; +>clear : () => void + + trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void; +>trackSymbol : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => void +>symbol : Symbol +>Symbol : Symbol +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags + } + const enum TypeFormatFlags { +>TypeFormatFlags : TypeFormatFlags + + None = 0, +>None : TypeFormatFlags + + WriteArrayAsGenericType = 1, +>WriteArrayAsGenericType : TypeFormatFlags + + UseTypeOfFunction = 2, +>UseTypeOfFunction : TypeFormatFlags + + NoTruncation = 4, +>NoTruncation : TypeFormatFlags + + WriteArrowStyleSignature = 8, +>WriteArrowStyleSignature : TypeFormatFlags + + WriteOwnNameForAnyLike = 16, +>WriteOwnNameForAnyLike : TypeFormatFlags + + WriteTypeArgumentsOfSignature = 32, +>WriteTypeArgumentsOfSignature : TypeFormatFlags + + InElementType = 64, +>InElementType : TypeFormatFlags + } + const enum SymbolFormatFlags { +>SymbolFormatFlags : SymbolFormatFlags + + None = 0, +>None : SymbolFormatFlags + + WriteTypeParametersOrArguments = 1, +>WriteTypeParametersOrArguments : SymbolFormatFlags + + UseOnlyExternalAliasing = 2, +>UseOnlyExternalAliasing : SymbolFormatFlags + } + const enum SymbolAccessibility { +>SymbolAccessibility : SymbolAccessibility + + Accessible = 0, +>Accessible : SymbolAccessibility + + NotAccessible = 1, +>NotAccessible : SymbolAccessibility + + CannotBeNamed = 2, +>CannotBeNamed : SymbolAccessibility + } + interface SymbolVisibilityResult { +>SymbolVisibilityResult : SymbolVisibilityResult + + accessibility: SymbolAccessibility; +>accessibility : SymbolAccessibility +>SymbolAccessibility : SymbolAccessibility + + aliasesToMakeVisible?: ImportDeclaration[]; +>aliasesToMakeVisible : ImportDeclaration[] +>ImportDeclaration : ImportDeclaration + + errorSymbolName?: string; +>errorSymbolName : string + + errorNode?: Node; +>errorNode : Node +>Node : Node + } + interface SymbolAccessiblityResult extends SymbolVisibilityResult { +>SymbolAccessiblityResult : SymbolAccessiblityResult +>SymbolVisibilityResult : SymbolVisibilityResult + + errorModuleName?: string; +>errorModuleName : string + } + interface EmitResolver { +>EmitResolver : EmitResolver + + getProgram(): Program; +>getProgram : () => Program +>Program : Program + + getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string; +>getLocalNameOfContainer : (container: EnumDeclaration | ModuleDeclaration) => string +>container : EnumDeclaration | ModuleDeclaration +>ModuleDeclaration : ModuleDeclaration +>EnumDeclaration : EnumDeclaration + + getExpressionNamePrefix(node: Identifier): string; +>getExpressionNamePrefix : (node: Identifier) => string +>node : Identifier +>Identifier : Identifier + + getExportAssignmentName(node: SourceFile): string; +>getExportAssignmentName : (node: SourceFile) => string +>node : SourceFile +>SourceFile : SourceFile + + isReferencedImportDeclaration(node: ImportDeclaration): boolean; +>isReferencedImportDeclaration : (node: ImportDeclaration) => boolean +>node : ImportDeclaration +>ImportDeclaration : ImportDeclaration + + isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; +>isTopLevelValueImportWithEntityName : (node: ImportDeclaration) => boolean +>node : ImportDeclaration +>ImportDeclaration : ImportDeclaration + + getNodeCheckFlags(node: Node): NodeCheckFlags; +>getNodeCheckFlags : (node: Node) => NodeCheckFlags +>node : Node +>Node : Node +>NodeCheckFlags : NodeCheckFlags + + getEnumMemberValue(node: EnumMember): number; +>getEnumMemberValue : (node: EnumMember) => number +>node : EnumMember +>EnumMember : EnumMember + + hasSemanticErrors(): boolean; +>hasSemanticErrors : () => boolean + + isDeclarationVisible(node: Declaration): boolean; +>isDeclarationVisible : (node: Declaration) => boolean +>node : Declaration +>Declaration : Declaration + + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; +>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean +>node : FunctionLikeDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration + + writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; +>writeTypeAtLocation : (location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void +>location : Node +>Node : Node +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags +>writer : SymbolWriter +>SymbolWriter : SymbolWriter + + writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; +>writeReturnTypeOfSignatureDeclaration : (signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void +>signatureDeclaration : SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags +>writer : SymbolWriter +>SymbolWriter : SymbolWriter + + isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult; +>isSymbolAccessible : (symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) => SymbolAccessiblityResult +>symbol : Symbol +>Symbol : Symbol +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags +>SymbolAccessiblityResult : SymbolAccessiblityResult + + isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult; +>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult +>entityName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName +>enclosingDeclaration : Node +>Node : Node +>SymbolVisibilityResult : SymbolVisibilityResult + + getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number; +>getConstantValue : (node: PropertyAccessExpression | ElementAccessExpression) => number +>node : PropertyAccessExpression | ElementAccessExpression +>PropertyAccessExpression : PropertyAccessExpression +>ElementAccessExpression : ElementAccessExpression + + isEmitBlocked(sourceFile?: SourceFile): boolean; +>isEmitBlocked : (sourceFile?: SourceFile) => boolean +>sourceFile : SourceFile +>SourceFile : SourceFile + } + const enum SymbolFlags { +>SymbolFlags : SymbolFlags + + FunctionScopedVariable = 1, +>FunctionScopedVariable : SymbolFlags + + BlockScopedVariable = 2, +>BlockScopedVariable : SymbolFlags + + Property = 4, +>Property : SymbolFlags + + EnumMember = 8, +>EnumMember : SymbolFlags + + Function = 16, +>Function : SymbolFlags + + Class = 32, +>Class : SymbolFlags + + Interface = 64, +>Interface : SymbolFlags + + ConstEnum = 128, +>ConstEnum : SymbolFlags + + RegularEnum = 256, +>RegularEnum : SymbolFlags + + ValueModule = 512, +>ValueModule : SymbolFlags + + NamespaceModule = 1024, +>NamespaceModule : SymbolFlags + + TypeLiteral = 2048, +>TypeLiteral : SymbolFlags + + ObjectLiteral = 4096, +>ObjectLiteral : SymbolFlags + + Method = 8192, +>Method : SymbolFlags + + Constructor = 16384, +>Constructor : SymbolFlags + + GetAccessor = 32768, +>GetAccessor : SymbolFlags + + SetAccessor = 65536, +>SetAccessor : SymbolFlags + + CallSignature = 131072, +>CallSignature : SymbolFlags + + ConstructSignature = 262144, +>ConstructSignature : SymbolFlags + + IndexSignature = 524288, +>IndexSignature : SymbolFlags + + TypeParameter = 1048576, +>TypeParameter : SymbolFlags + + TypeAlias = 2097152, +>TypeAlias : SymbolFlags + + ExportValue = 4194304, +>ExportValue : SymbolFlags + + ExportType = 8388608, +>ExportType : SymbolFlags + + ExportNamespace = 16777216, +>ExportNamespace : SymbolFlags + + Import = 33554432, +>Import : SymbolFlags + + Instantiated = 67108864, +>Instantiated : SymbolFlags + + Merged = 134217728, +>Merged : SymbolFlags + + Transient = 268435456, +>Transient : SymbolFlags + + Prototype = 536870912, +>Prototype : SymbolFlags + + UnionProperty = 1073741824, +>UnionProperty : SymbolFlags + + Enum = 384, +>Enum : SymbolFlags + + Variable = 3, +>Variable : SymbolFlags + + Value = 107455, +>Value : SymbolFlags + + Type = 3152352, +>Type : SymbolFlags + + Namespace = 1536, +>Namespace : SymbolFlags + + Module = 1536, +>Module : SymbolFlags + + Accessor = 98304, +>Accessor : SymbolFlags + + Signature = 917504, +>Signature : SymbolFlags + + FunctionScopedVariableExcludes = 107454, +>FunctionScopedVariableExcludes : SymbolFlags + + BlockScopedVariableExcludes = 107455, +>BlockScopedVariableExcludes : SymbolFlags + + ParameterExcludes = 107455, +>ParameterExcludes : SymbolFlags + + PropertyExcludes = 107455, +>PropertyExcludes : SymbolFlags + + EnumMemberExcludes = 107455, +>EnumMemberExcludes : SymbolFlags + + FunctionExcludes = 106927, +>FunctionExcludes : SymbolFlags + + ClassExcludes = 3258879, +>ClassExcludes : SymbolFlags + + InterfaceExcludes = 3152288, +>InterfaceExcludes : SymbolFlags + + RegularEnumExcludes = 3258623, +>RegularEnumExcludes : SymbolFlags + + ConstEnumExcludes = 3259263, +>ConstEnumExcludes : SymbolFlags + + ValueModuleExcludes = 106639, +>ValueModuleExcludes : SymbolFlags + + NamespaceModuleExcludes = 0, +>NamespaceModuleExcludes : SymbolFlags + + MethodExcludes = 99263, +>MethodExcludes : SymbolFlags + + GetAccessorExcludes = 41919, +>GetAccessorExcludes : SymbolFlags + + SetAccessorExcludes = 74687, +>SetAccessorExcludes : SymbolFlags + + TypeParameterExcludes = 2103776, +>TypeParameterExcludes : SymbolFlags + + TypeAliasExcludes = 3152352, +>TypeAliasExcludes : SymbolFlags + + ImportExcludes = 33554432, +>ImportExcludes : SymbolFlags + + ModuleMember = 35653619, +>ModuleMember : SymbolFlags + + ExportHasLocal = 944, +>ExportHasLocal : SymbolFlags + + HasLocals = 1041936, +>HasLocals : SymbolFlags + + HasExports = 1952, +>HasExports : SymbolFlags + + HasMembers = 6240, +>HasMembers : SymbolFlags + + IsContainer = 1048560, +>IsContainer : SymbolFlags + + PropertyOrAccessor = 98308, +>PropertyOrAccessor : SymbolFlags + + Export = 29360128, +>Export : SymbolFlags + } + interface Symbol { +>Symbol : Symbol + + flags: SymbolFlags; +>flags : SymbolFlags +>SymbolFlags : SymbolFlags + + name: string; +>name : string + + id?: number; +>id : number + + mergeId?: number; +>mergeId : number + + declarations?: Declaration[]; +>declarations : Declaration[] +>Declaration : Declaration + + parent?: Symbol; +>parent : Symbol +>Symbol : Symbol + + members?: SymbolTable; +>members : SymbolTable +>SymbolTable : SymbolTable + + exports?: SymbolTable; +>exports : SymbolTable +>SymbolTable : SymbolTable + + exportSymbol?: Symbol; +>exportSymbol : Symbol +>Symbol : Symbol + + valueDeclaration?: Declaration; +>valueDeclaration : Declaration +>Declaration : Declaration + + constEnumOnlyModule?: boolean; +>constEnumOnlyModule : boolean + } + interface SymbolLinks { +>SymbolLinks : SymbolLinks + + target?: Symbol; +>target : Symbol +>Symbol : Symbol + + type?: Type; +>type : Type +>Type : Type + + declaredType?: Type; +>declaredType : Type +>Type : Type + + mapper?: TypeMapper; +>mapper : TypeMapper +>TypeMapper : TypeMapper + + referenced?: boolean; +>referenced : boolean + + exportAssignSymbol?: Symbol; +>exportAssignSymbol : Symbol +>Symbol : Symbol + + unionType?: UnionType; +>unionType : UnionType +>UnionType : UnionType + } + interface TransientSymbol extends Symbol, SymbolLinks { +>TransientSymbol : TransientSymbol +>Symbol : Symbol +>SymbolLinks : SymbolLinks + } + interface SymbolTable { +>SymbolTable : SymbolTable + + [index: string]: Symbol; +>index : string +>Symbol : Symbol + } + const enum NodeCheckFlags { +>NodeCheckFlags : NodeCheckFlags + + TypeChecked = 1, +>TypeChecked : NodeCheckFlags + + LexicalThis = 2, +>LexicalThis : NodeCheckFlags + + CaptureThis = 4, +>CaptureThis : NodeCheckFlags + + EmitExtends = 8, +>EmitExtends : NodeCheckFlags + + SuperInstance = 16, +>SuperInstance : NodeCheckFlags + + SuperStatic = 32, +>SuperStatic : NodeCheckFlags + + ContextChecked = 64, +>ContextChecked : NodeCheckFlags + + EnumValuesComputed = 128, +>EnumValuesComputed : NodeCheckFlags + } + interface NodeLinks { +>NodeLinks : NodeLinks + + resolvedType?: Type; +>resolvedType : Type +>Type : Type + + resolvedSignature?: Signature; +>resolvedSignature : Signature +>Signature : Signature + + resolvedSymbol?: Symbol; +>resolvedSymbol : Symbol +>Symbol : Symbol + + flags?: NodeCheckFlags; +>flags : NodeCheckFlags +>NodeCheckFlags : NodeCheckFlags + + enumMemberValue?: number; +>enumMemberValue : number + + isIllegalTypeReferenceInConstraint?: boolean; +>isIllegalTypeReferenceInConstraint : boolean + + isVisible?: boolean; +>isVisible : boolean + + localModuleName?: string; +>localModuleName : string + + assignmentChecks?: Map; +>assignmentChecks : Map +>Map : Map + } + const enum TypeFlags { +>TypeFlags : TypeFlags + + Any = 1, +>Any : TypeFlags + + String = 2, +>String : TypeFlags + + Number = 4, +>Number : TypeFlags + + Boolean = 8, +>Boolean : TypeFlags + + Void = 16, +>Void : TypeFlags + + Undefined = 32, +>Undefined : TypeFlags + + Null = 64, +>Null : TypeFlags + + Enum = 128, +>Enum : TypeFlags + + StringLiteral = 256, +>StringLiteral : TypeFlags + + TypeParameter = 512, +>TypeParameter : TypeFlags + + Class = 1024, +>Class : TypeFlags + + Interface = 2048, +>Interface : TypeFlags + + Reference = 4096, +>Reference : TypeFlags + + Tuple = 8192, +>Tuple : TypeFlags + + Union = 16384, +>Union : TypeFlags + + Anonymous = 32768, +>Anonymous : TypeFlags + + FromSignature = 65536, +>FromSignature : TypeFlags + + Intrinsic = 127, +>Intrinsic : TypeFlags + + StringLike = 258, +>StringLike : TypeFlags + + NumberLike = 132, +>NumberLike : TypeFlags + + ObjectType = 48128, +>ObjectType : TypeFlags + + Structured = 65025, +>Structured : TypeFlags + } + interface Type { +>Type : Type + + flags: TypeFlags; +>flags : TypeFlags +>TypeFlags : TypeFlags + + id: number; +>id : number + + symbol?: Symbol; +>symbol : Symbol +>Symbol : Symbol + } + interface IntrinsicType extends Type { +>IntrinsicType : IntrinsicType +>Type : Type + + intrinsicName: string; +>intrinsicName : string + } + interface StringLiteralType extends Type { +>StringLiteralType : StringLiteralType +>Type : Type + + text: string; +>text : string + } + interface ObjectType extends Type { +>ObjectType : ObjectType +>Type : Type + } + interface InterfaceType extends ObjectType { +>InterfaceType : InterfaceType +>ObjectType : ObjectType + + typeParameters: TypeParameter[]; +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter + + baseTypes: ObjectType[]; +>baseTypes : ObjectType[] +>ObjectType : ObjectType + + declaredProperties: Symbol[]; +>declaredProperties : Symbol[] +>Symbol : Symbol + + declaredCallSignatures: Signature[]; +>declaredCallSignatures : Signature[] +>Signature : Signature + + declaredConstructSignatures: Signature[]; +>declaredConstructSignatures : Signature[] +>Signature : Signature + + declaredStringIndexType: Type; +>declaredStringIndexType : Type +>Type : Type + + declaredNumberIndexType: Type; +>declaredNumberIndexType : Type +>Type : Type + } + interface TypeReference extends ObjectType { +>TypeReference : TypeReference +>ObjectType : ObjectType + + target: GenericType; +>target : GenericType +>GenericType : GenericType + + typeArguments: Type[]; +>typeArguments : Type[] +>Type : Type + } + interface GenericType extends InterfaceType, TypeReference { +>GenericType : GenericType +>InterfaceType : InterfaceType +>TypeReference : TypeReference + + instantiations: Map; +>instantiations : Map +>Map : Map +>TypeReference : TypeReference + + openReferenceTargets: GenericType[]; +>openReferenceTargets : GenericType[] +>GenericType : GenericType + + openReferenceChecks: Map; +>openReferenceChecks : Map +>Map : Map + } + interface TupleType extends ObjectType { +>TupleType : TupleType +>ObjectType : ObjectType + + elementTypes: Type[]; +>elementTypes : Type[] +>Type : Type + + baseArrayType: TypeReference; +>baseArrayType : TypeReference +>TypeReference : TypeReference + } + interface UnionType extends Type { +>UnionType : UnionType +>Type : Type + + types: Type[]; +>types : Type[] +>Type : Type + + resolvedProperties: SymbolTable; +>resolvedProperties : SymbolTable +>SymbolTable : SymbolTable + } + interface ResolvedType extends ObjectType, UnionType { +>ResolvedType : ResolvedType +>ObjectType : ObjectType +>UnionType : UnionType + + members: SymbolTable; +>members : SymbolTable +>SymbolTable : SymbolTable + + properties: Symbol[]; +>properties : Symbol[] +>Symbol : Symbol + + callSignatures: Signature[]; +>callSignatures : Signature[] +>Signature : Signature + + constructSignatures: Signature[]; +>constructSignatures : Signature[] +>Signature : Signature + + stringIndexType: Type; +>stringIndexType : Type +>Type : Type + + numberIndexType: Type; +>numberIndexType : Type +>Type : Type + } + interface TypeParameter extends Type { +>TypeParameter : TypeParameter +>Type : Type + + constraint: Type; +>constraint : Type +>Type : Type + + target?: TypeParameter; +>target : TypeParameter +>TypeParameter : TypeParameter + + mapper?: TypeMapper; +>mapper : TypeMapper +>TypeMapper : TypeMapper + } + const enum SignatureKind { +>SignatureKind : SignatureKind + + Call = 0, +>Call : SignatureKind + + Construct = 1, +>Construct : SignatureKind + } + interface Signature { +>Signature : Signature + + declaration: SignatureDeclaration; +>declaration : SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration + + typeParameters: TypeParameter[]; +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter + + parameters: Symbol[]; +>parameters : Symbol[] +>Symbol : Symbol + + resolvedReturnType: Type; +>resolvedReturnType : Type +>Type : Type + + minArgumentCount: number; +>minArgumentCount : number + + hasRestParameter: boolean; +>hasRestParameter : boolean + + hasStringLiterals: boolean; +>hasStringLiterals : boolean + + target?: Signature; +>target : Signature +>Signature : Signature + + mapper?: TypeMapper; +>mapper : TypeMapper +>TypeMapper : TypeMapper + + unionSignatures?: Signature[]; +>unionSignatures : Signature[] +>Signature : Signature + + erasedSignatureCache?: Signature; +>erasedSignatureCache : Signature +>Signature : Signature + + isolatedSignatureType?: ObjectType; +>isolatedSignatureType : ObjectType +>ObjectType : ObjectType + } + const enum IndexKind { +>IndexKind : IndexKind + + String = 0, +>String : IndexKind + + Number = 1, +>Number : IndexKind + } + interface TypeMapper { +>TypeMapper : TypeMapper + + (t: Type): Type; +>t : Type +>Type : Type +>Type : Type + } + interface TypeInferences { +>TypeInferences : TypeInferences + + primary: Type[]; +>primary : Type[] +>Type : Type + + secondary: Type[]; +>secondary : Type[] +>Type : Type + } + interface InferenceContext { +>InferenceContext : InferenceContext + + typeParameters: TypeParameter[]; +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter + + inferUnionTypes: boolean; +>inferUnionTypes : boolean + + inferences: TypeInferences[]; +>inferences : TypeInferences[] +>TypeInferences : TypeInferences + + inferredTypes: Type[]; +>inferredTypes : Type[] +>Type : Type + + failedTypeParameterIndex?: number; +>failedTypeParameterIndex : number + } + interface DiagnosticMessage { +>DiagnosticMessage : DiagnosticMessage + + key: string; +>key : string + + category: DiagnosticCategory; +>category : DiagnosticCategory +>DiagnosticCategory : DiagnosticCategory + + code: number; +>code : number + + isEarly?: boolean; +>isEarly : boolean + } + interface DiagnosticMessageChain { +>DiagnosticMessageChain : DiagnosticMessageChain + + messageText: string; +>messageText : string + + category: DiagnosticCategory; +>category : DiagnosticCategory +>DiagnosticCategory : DiagnosticCategory + + code: number; +>code : number + + next?: DiagnosticMessageChain; +>next : DiagnosticMessageChain +>DiagnosticMessageChain : DiagnosticMessageChain + } + interface Diagnostic { +>Diagnostic : Diagnostic + + file: SourceFile; +>file : SourceFile +>SourceFile : SourceFile + + start: number; +>start : number + + length: number; +>length : number + + messageText: string; +>messageText : string + + category: DiagnosticCategory; +>category : DiagnosticCategory +>DiagnosticCategory : DiagnosticCategory + + code: number; +>code : number + + /** + * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit + */ + isEarly?: boolean; +>isEarly : boolean + + /** + * Parse error - error produced by parser when it scanner returns a token + * that parser does not understand in its current state + * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) + */ + isParseError?: boolean; +>isParseError : boolean + } + enum DiagnosticCategory { +>DiagnosticCategory : DiagnosticCategory + + Warning = 0, +>Warning : DiagnosticCategory + + Error = 1, +>Error : DiagnosticCategory + + Message = 2, +>Message : DiagnosticCategory + } + interface CompilerOptions { +>CompilerOptions : CompilerOptions + + charset?: string; +>charset : string + + codepage?: number; +>codepage : number + + declaration?: boolean; +>declaration : boolean + + diagnostics?: boolean; +>diagnostics : boolean + + emitBOM?: boolean; +>emitBOM : boolean + + help?: boolean; +>help : boolean + + locale?: string; +>locale : string + + mapRoot?: string; +>mapRoot : string + + module?: ModuleKind; +>module : ModuleKind +>ModuleKind : ModuleKind + + noEmitOnError?: boolean; +>noEmitOnError : boolean + + noErrorTruncation?: boolean; +>noErrorTruncation : boolean + + noImplicitAny?: boolean; +>noImplicitAny : boolean + + noLib?: boolean; +>noLib : boolean + + noLibCheck?: boolean; +>noLibCheck : boolean + + noResolve?: boolean; +>noResolve : boolean + + out?: string; +>out : string + + outDir?: string; +>outDir : string + + removeComments?: boolean; +>removeComments : boolean + + sourceMap?: boolean; +>sourceMap : boolean + + sourceRoot?: string; +>sourceRoot : string + + target?: ScriptTarget; +>target : ScriptTarget +>ScriptTarget : ScriptTarget + + version?: boolean; +>version : boolean + + watch?: boolean; +>watch : boolean + + preserveConstEnums?: boolean; +>preserveConstEnums : boolean + + [option: string]: string | number | boolean; +>option : string + } + const enum ModuleKind { +>ModuleKind : ModuleKind + + None = 0, +>None : ModuleKind + + CommonJS = 1, +>CommonJS : ModuleKind + + AMD = 2, +>AMD : ModuleKind + } + interface LineAndCharacter { +>LineAndCharacter : LineAndCharacter + + line: number; +>line : number + + character: number; +>character : number + } + const enum ScriptTarget { +>ScriptTarget : ScriptTarget + + ES3 = 0, +>ES3 : ScriptTarget + + ES5 = 1, +>ES5 : ScriptTarget + + ES6 = 2, +>ES6 : ScriptTarget + + Latest = 2, +>Latest : ScriptTarget + } + interface ParsedCommandLine { +>ParsedCommandLine : ParsedCommandLine + + options: CompilerOptions; +>options : CompilerOptions +>CompilerOptions : CompilerOptions + + filenames: string[]; +>filenames : string[] + + errors: Diagnostic[]; +>errors : Diagnostic[] +>Diagnostic : Diagnostic + } + interface CommandLineOption { +>CommandLineOption : CommandLineOption + + name: string; +>name : string + + type: string | Map; +>type : string | Map +>Map : Map + + shortName?: string; +>shortName : string + + description?: DiagnosticMessage; +>description : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + + paramName?: DiagnosticMessage; +>paramName : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + + error?: DiagnosticMessage; +>error : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + } + const enum CharacterCodes { +>CharacterCodes : CharacterCodes + + nullCharacter = 0, +>nullCharacter : CharacterCodes + + maxAsciiCharacter = 127, +>maxAsciiCharacter : CharacterCodes + + lineFeed = 10, +>lineFeed : CharacterCodes + + carriageReturn = 13, +>carriageReturn : CharacterCodes + + lineSeparator = 8232, +>lineSeparator : CharacterCodes + + paragraphSeparator = 8233, +>paragraphSeparator : CharacterCodes + + nextLine = 133, +>nextLine : CharacterCodes + + space = 32, +>space : CharacterCodes + + nonBreakingSpace = 160, +>nonBreakingSpace : CharacterCodes + + enQuad = 8192, +>enQuad : CharacterCodes + + emQuad = 8193, +>emQuad : CharacterCodes + + enSpace = 8194, +>enSpace : CharacterCodes + + emSpace = 8195, +>emSpace : CharacterCodes + + threePerEmSpace = 8196, +>threePerEmSpace : CharacterCodes + + fourPerEmSpace = 8197, +>fourPerEmSpace : CharacterCodes + + sixPerEmSpace = 8198, +>sixPerEmSpace : CharacterCodes + + figureSpace = 8199, +>figureSpace : CharacterCodes + + punctuationSpace = 8200, +>punctuationSpace : CharacterCodes + + thinSpace = 8201, +>thinSpace : CharacterCodes + + hairSpace = 8202, +>hairSpace : CharacterCodes + + zeroWidthSpace = 8203, +>zeroWidthSpace : CharacterCodes + + narrowNoBreakSpace = 8239, +>narrowNoBreakSpace : CharacterCodes + + ideographicSpace = 12288, +>ideographicSpace : CharacterCodes + + mathematicalSpace = 8287, +>mathematicalSpace : CharacterCodes + + ogham = 5760, +>ogham : CharacterCodes + + _ = 95, +>_ : CharacterCodes + + $ = 36, +>$ : CharacterCodes + + _0 = 48, +>_0 : CharacterCodes + + _1 = 49, +>_1 : CharacterCodes + + _2 = 50, +>_2 : CharacterCodes + + _3 = 51, +>_3 : CharacterCodes + + _4 = 52, +>_4 : CharacterCodes + + _5 = 53, +>_5 : CharacterCodes + + _6 = 54, +>_6 : CharacterCodes + + _7 = 55, +>_7 : CharacterCodes + + _8 = 56, +>_8 : CharacterCodes + + _9 = 57, +>_9 : CharacterCodes + + a = 97, +>a : CharacterCodes + + b = 98, +>b : CharacterCodes + + c = 99, +>c : CharacterCodes + + d = 100, +>d : CharacterCodes + + e = 101, +>e : CharacterCodes + + f = 102, +>f : CharacterCodes + + g = 103, +>g : CharacterCodes + + h = 104, +>h : CharacterCodes + + i = 105, +>i : CharacterCodes + + j = 106, +>j : CharacterCodes + + k = 107, +>k : CharacterCodes + + l = 108, +>l : CharacterCodes + + m = 109, +>m : CharacterCodes + + n = 110, +>n : CharacterCodes + + o = 111, +>o : CharacterCodes + + p = 112, +>p : CharacterCodes + + q = 113, +>q : CharacterCodes + + r = 114, +>r : CharacterCodes + + s = 115, +>s : CharacterCodes + + t = 116, +>t : CharacterCodes + + u = 117, +>u : CharacterCodes + + v = 118, +>v : CharacterCodes + + w = 119, +>w : CharacterCodes + + x = 120, +>x : CharacterCodes + + y = 121, +>y : CharacterCodes + + z = 122, +>z : CharacterCodes + + A = 65, +>A : CharacterCodes + + B = 66, +>B : CharacterCodes + + C = 67, +>C : CharacterCodes + + D = 68, +>D : CharacterCodes + + E = 69, +>E : CharacterCodes + + F = 70, +>F : CharacterCodes + + G = 71, +>G : CharacterCodes + + H = 72, +>H : CharacterCodes + + I = 73, +>I : CharacterCodes + + J = 74, +>J : CharacterCodes + + K = 75, +>K : CharacterCodes + + L = 76, +>L : CharacterCodes + + M = 77, +>M : CharacterCodes + + N = 78, +>N : CharacterCodes + + O = 79, +>O : CharacterCodes + + P = 80, +>P : CharacterCodes + + Q = 81, +>Q : CharacterCodes + + R = 82, +>R : CharacterCodes + + S = 83, +>S : CharacterCodes + + T = 84, +>T : CharacterCodes + + U = 85, +>U : CharacterCodes + + V = 86, +>V : CharacterCodes + + W = 87, +>W : CharacterCodes + + X = 88, +>X : CharacterCodes + + Y = 89, +>Y : CharacterCodes + + Z = 90, +>Z : CharacterCodes + + ampersand = 38, +>ampersand : CharacterCodes + + asterisk = 42, +>asterisk : CharacterCodes + + at = 64, +>at : CharacterCodes + + backslash = 92, +>backslash : CharacterCodes + + backtick = 96, +>backtick : CharacterCodes + + bar = 124, +>bar : CharacterCodes + + caret = 94, +>caret : CharacterCodes + + closeBrace = 125, +>closeBrace : CharacterCodes + + closeBracket = 93, +>closeBracket : CharacterCodes + + closeParen = 41, +>closeParen : CharacterCodes + + colon = 58, +>colon : CharacterCodes + + comma = 44, +>comma : CharacterCodes + + dot = 46, +>dot : CharacterCodes + + doubleQuote = 34, +>doubleQuote : CharacterCodes + + equals = 61, +>equals : CharacterCodes + + exclamation = 33, +>exclamation : CharacterCodes + + greaterThan = 62, +>greaterThan : CharacterCodes + + lessThan = 60, +>lessThan : CharacterCodes + + minus = 45, +>minus : CharacterCodes + + openBrace = 123, +>openBrace : CharacterCodes + + openBracket = 91, +>openBracket : CharacterCodes + + openParen = 40, +>openParen : CharacterCodes + + percent = 37, +>percent : CharacterCodes + + plus = 43, +>plus : CharacterCodes + + question = 63, +>question : CharacterCodes + + semicolon = 59, +>semicolon : CharacterCodes + + singleQuote = 39, +>singleQuote : CharacterCodes + + slash = 47, +>slash : CharacterCodes + + tilde = 126, +>tilde : CharacterCodes + + backspace = 8, +>backspace : CharacterCodes + + formFeed = 12, +>formFeed : CharacterCodes + + byteOrderMark = 65279, +>byteOrderMark : CharacterCodes + + tab = 9, +>tab : CharacterCodes + + verticalTab = 11, +>verticalTab : CharacterCodes + } + interface CancellationToken { +>CancellationToken : CancellationToken + + isCancellationRequested(): boolean; +>isCancellationRequested : () => boolean + } + interface CompilerHost { +>CompilerHost : CompilerHost + + getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; +>getSourceFile : (filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void) => SourceFile +>filename : string +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget +>onError : (message: string) => void +>message : string +>SourceFile : SourceFile + + getDefaultLibFilename(): string; +>getDefaultLibFilename : () => string + + getCancellationToken?(): CancellationToken; +>getCancellationToken : () => CancellationToken +>CancellationToken : CancellationToken + + writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; +>writeFile : (filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) => void +>filename : string +>data : string +>writeByteOrderMark : boolean +>onError : (message: string) => void +>message : string + + getCurrentDirectory(): string; +>getCurrentDirectory : () => string + + getCanonicalFileName(fileName: string): string; +>getCanonicalFileName : (fileName: string) => string +>fileName : string + + useCaseSensitiveFileNames(): boolean; +>useCaseSensitiveFileNames : () => boolean + + getNewLine(): string; +>getNewLine : () => string + } +} +declare module ts { +>ts : typeof ts + + interface ErrorCallback { +>ErrorCallback : ErrorCallback + + (message: DiagnosticMessage): void; +>message : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + } + interface CommentCallback { +>CommentCallback : CommentCallback + + (pos: number, end: number): void; +>pos : number +>end : number + } + interface Scanner { +>Scanner : Scanner + + getStartPos(): number; +>getStartPos : () => number + + getToken(): SyntaxKind; +>getToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + getTextPos(): number; +>getTextPos : () => number + + getTokenPos(): number; +>getTokenPos : () => number + + getTokenText(): string; +>getTokenText : () => string + + getTokenValue(): string; +>getTokenValue : () => string + + hasPrecedingLineBreak(): boolean; +>hasPrecedingLineBreak : () => boolean + + isIdentifier(): boolean; +>isIdentifier : () => boolean + + isReservedWord(): boolean; +>isReservedWord : () => boolean + + reScanGreaterToken(): SyntaxKind; +>reScanGreaterToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + reScanSlashToken(): SyntaxKind; +>reScanSlashToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + reScanTemplateToken(): SyntaxKind; +>reScanTemplateToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + scan(): SyntaxKind; +>scan : () => SyntaxKind +>SyntaxKind : SyntaxKind + + setText(text: string): void; +>setText : (text: string) => void +>text : string + + setTextPos(textPos: number): void; +>setTextPos : (textPos: number) => void +>textPos : number + + tryScan(callback: () => T): T; +>tryScan : (callback: () => T) => T +>T : T +>callback : () => T +>T : T +>T : T + } + function tokenToString(t: SyntaxKind): string; +>tokenToString : (t: SyntaxKind) => string +>t : SyntaxKind +>SyntaxKind : SyntaxKind + + function computeLineStarts(text: string): number[]; +>computeLineStarts : (text: string) => number[] +>text : string + + function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number; +>getPositionFromLineAndCharacter : (lineStarts: number[], line: number, character: number) => number +>lineStarts : number[] +>line : number +>character : number + + function getLineAndCharacterOfPosition(lineStarts: number[], position: number): { +>getLineAndCharacterOfPosition : (lineStarts: number[], position: number) => { line: number; character: number; } +>lineStarts : number[] +>position : number + + line: number; +>line : number + + character: number; +>character : number + + }; + function positionToLineAndCharacter(text: string, pos: number): { +>positionToLineAndCharacter : (text: string, pos: number) => { line: number; character: number; } +>text : string +>pos : number + + line: number; +>line : number + + character: number; +>character : number + + }; + function isWhiteSpace(ch: number): boolean; +>isWhiteSpace : (ch: number) => boolean +>ch : number + + function isLineBreak(ch: number): boolean; +>isLineBreak : (ch: number) => boolean +>ch : number + + function isOctalDigit(ch: number): boolean; +>isOctalDigit : (ch: number) => boolean +>ch : number + + function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number; +>skipTrivia : (text: string, pos: number, stopAfterLineBreak?: boolean) => number +>text : string +>pos : number +>stopAfterLineBreak : boolean + + function getLeadingCommentRanges(text: string, pos: number): CommentRange[]; +>getLeadingCommentRanges : (text: string, pos: number) => CommentRange[] +>text : string +>pos : number +>CommentRange : CommentRange + + function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; +>getTrailingCommentRanges : (text: string, pos: number) => CommentRange[] +>text : string +>pos : number +>CommentRange : CommentRange + + function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; +>isIdentifierStart : (ch: number, languageVersion: ScriptTarget) => boolean +>ch : number +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget + + function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; +>isIdentifierPart : (ch: number, languageVersion: ScriptTarget) => boolean +>ch : number +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget + + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; +>createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback) => Scanner +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget +>skipTrivia : boolean +>text : string +>onError : ErrorCallback +>ErrorCallback : ErrorCallback +>onComment : CommentCallback +>CommentCallback : CommentCallback +>Scanner : Scanner +} +declare module ts { +>ts : typeof ts + + interface ReferencePathMatchResult { +>ReferencePathMatchResult : ReferencePathMatchResult + + fileReference?: FileReference; +>fileReference : FileReference +>FileReference : FileReference + + diagnostic?: DiagnosticMessage; +>diagnostic : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + + isNoDefaultLib?: boolean; +>isNoDefaultLib : boolean + } + function getNodeConstructor(kind: SyntaxKind): new () => Node; +>getNodeConstructor : (kind: SyntaxKind) => new () => Node +>kind : SyntaxKind +>SyntaxKind : SyntaxKind +>Node : Node + + function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; +>forEachChild : (node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T) => T +>T : T +>node : Node +>Node : Node +>cbNode : (node: Node) => T +>node : Node +>Node : Node +>T : T +>cbNodes : (nodes: Node[]) => T +>nodes : Node[] +>Node : Node +>T : T +>T : T + + function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; +>createSourceFile : (filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean) => SourceFile +>filename : string +>sourceText : string +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget +>version : string +>isOpen : boolean +>SourceFile : SourceFile + + function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program; +>createProgram : (rootNames: string[], options: CompilerOptions, host: CompilerHost) => Program +>rootNames : string[] +>options : CompilerOptions +>CompilerOptions : CompilerOptions +>host : CompilerHost +>CompilerHost : CompilerHost +>Program : Program +} +declare module ts { +>ts : typeof ts + + function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker; +>createTypeChecker : (program: Program, fullTypeCheck: boolean) => TypeChecker +>program : Program +>Program : Program +>fullTypeCheck : boolean +>TypeChecker : TypeChecker +} +declare module ts { +>ts : typeof ts + + interface Node { +>Node : Node + + getSourceFile(): SourceFile; +>getSourceFile : () => SourceFile +>SourceFile : SourceFile + + getChildCount(sourceFile?: SourceFile): number; +>getChildCount : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getChildAt(index: number, sourceFile?: SourceFile): Node; +>getChildAt : (index: number, sourceFile?: SourceFile) => Node +>index : number +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + + getChildren(sourceFile?: SourceFile): Node[]; +>getChildren : (sourceFile?: SourceFile) => Node[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + + getStart(sourceFile?: SourceFile): number; +>getStart : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFullStart(): number; +>getFullStart : () => number + + getEnd(): number; +>getEnd : () => number + + getWidth(sourceFile?: SourceFile): number; +>getWidth : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFullWidth(): number; +>getFullWidth : () => number + + getLeadingTriviaWidth(sourceFile?: SourceFile): number; +>getLeadingTriviaWidth : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFullText(sourceFile?: SourceFile): string; +>getFullText : (sourceFile?: SourceFile) => string +>sourceFile : SourceFile +>SourceFile : SourceFile + + getText(sourceFile?: SourceFile): string; +>getText : (sourceFile?: SourceFile) => string +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFirstToken(sourceFile?: SourceFile): Node; +>getFirstToken : (sourceFile?: SourceFile) => Node +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + + getLastToken(sourceFile?: SourceFile): Node; +>getLastToken : (sourceFile?: SourceFile) => Node +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + } + interface Symbol { +>Symbol : Symbol + + getFlags(): SymbolFlags; +>getFlags : () => SymbolFlags +>SymbolFlags : SymbolFlags + + getName(): string; +>getName : () => string + + getDeclarations(): Declaration[]; +>getDeclarations : () => Declaration[] +>Declaration : Declaration + + getDocumentationComment(): SymbolDisplayPart[]; +>getDocumentationComment : () => SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface Type { +>Type : Type + + getFlags(): TypeFlags; +>getFlags : () => TypeFlags +>TypeFlags : TypeFlags + + getSymbol(): Symbol; +>getSymbol : () => Symbol +>Symbol : Symbol + + getProperties(): Symbol[]; +>getProperties : () => Symbol[] +>Symbol : Symbol + + getProperty(propertyName: string): Symbol; +>getProperty : (propertyName: string) => Symbol +>propertyName : string +>Symbol : Symbol + + getApparentProperties(): Symbol[]; +>getApparentProperties : () => Symbol[] +>Symbol : Symbol + + getCallSignatures(): Signature[]; +>getCallSignatures : () => Signature[] +>Signature : Signature + + getConstructSignatures(): Signature[]; +>getConstructSignatures : () => Signature[] +>Signature : Signature + + getStringIndexType(): Type; +>getStringIndexType : () => Type +>Type : Type + + getNumberIndexType(): Type; +>getNumberIndexType : () => Type +>Type : Type + } + interface Signature { +>Signature : Signature + + getDeclaration(): SignatureDeclaration; +>getDeclaration : () => SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration + + getTypeParameters(): Type[]; +>getTypeParameters : () => Type[] +>Type : Type + + getParameters(): Symbol[]; +>getParameters : () => Symbol[] +>Symbol : Symbol + + getReturnType(): Type; +>getReturnType : () => Type +>Type : Type + + getDocumentationComment(): SymbolDisplayPart[]; +>getDocumentationComment : () => SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface SourceFile { +>SourceFile : SourceFile + + getScriptSnapshot(): IScriptSnapshot; +>getScriptSnapshot : () => IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot + + getNamedDeclarations(): Declaration[]; +>getNamedDeclarations : () => Declaration[] +>Declaration : Declaration + + update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; +>update : (scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile +>scriptSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>version : string +>isOpen : boolean +>textChangeRange : TextChangeRange +>TextChangeRange : TextChangeRange +>SourceFile : SourceFile + } + /** + * Represents an immutable snapshot of a script at a specified time.Once acquired, the + * snapshot is observably immutable. i.e. the same calls with the same parameters will return + * the same values. + */ + interface IScriptSnapshot { +>IScriptSnapshot : IScriptSnapshot + + /** Gets a portion of the script snapshot specified by [start, end). */ + getText(start: number, end: number): string; +>getText : (start: number, end: number) => string +>start : number +>end : number + + /** Gets the length of this script snapshot. */ + getLength(): number; +>getLength : () => number + + /** + * This call returns the array containing the start position of every line. + * i.e."[0, 10, 55]". TODO: consider making this optional. The language service could + * always determine this (albeit in a more expensive manner). + */ + getLineStartPositions(): number[]; +>getLineStartPositions : () => number[] + + /** + * Gets the TextChangeRange that describe how the text changed between this text and + * an older version. This information is used by the incremental parser to determine + * what sections of the script need to be re-parsed. 'undefined' can be returned if the + * change range cannot be determined. However, in that case, incremental parsing will + * not happen and the entire document will be re - parsed. + */ + getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange; +>getChangeRange : (oldSnapshot: IScriptSnapshot) => TextChangeRange +>oldSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>TextChangeRange : TextChangeRange + } + module ScriptSnapshot { +>ScriptSnapshot : typeof ScriptSnapshot + + function fromString(text: string): IScriptSnapshot; +>fromString : (text: string) => IScriptSnapshot +>text : string +>IScriptSnapshot : IScriptSnapshot + } + interface PreProcessedFileInfo { +>PreProcessedFileInfo : PreProcessedFileInfo + + referencedFiles: FileReference[]; +>referencedFiles : FileReference[] +>FileReference : FileReference + + importedFiles: FileReference[]; +>importedFiles : FileReference[] +>FileReference : FileReference + + isLibFile: boolean; +>isLibFile : boolean + } + interface Logger { +>Logger : Logger + + log(s: string): void; +>log : (s: string) => void +>s : string + } + interface LanguageServiceHost extends Logger { +>LanguageServiceHost : LanguageServiceHost +>Logger : Logger + + getCompilationSettings(): CompilerOptions; +>getCompilationSettings : () => CompilerOptions +>CompilerOptions : CompilerOptions + + getScriptFileNames(): string[]; +>getScriptFileNames : () => string[] + + getScriptVersion(fileName: string): string; +>getScriptVersion : (fileName: string) => string +>fileName : string + + getScriptIsOpen(fileName: string): boolean; +>getScriptIsOpen : (fileName: string) => boolean +>fileName : string + + getScriptSnapshot(fileName: string): IScriptSnapshot; +>getScriptSnapshot : (fileName: string) => IScriptSnapshot +>fileName : string +>IScriptSnapshot : IScriptSnapshot + + getLocalizedDiagnosticMessages(): any; +>getLocalizedDiagnosticMessages : () => any + + getCancellationToken(): CancellationToken; +>getCancellationToken : () => CancellationToken +>CancellationToken : CancellationToken + + getCurrentDirectory(): string; +>getCurrentDirectory : () => string + + getDefaultLibFilename(): string; +>getDefaultLibFilename : () => string + } + interface LanguageService { +>LanguageService : LanguageService + + cleanupSemanticCache(): void; +>cleanupSemanticCache : () => void + + getSyntacticDiagnostics(fileName: string): Diagnostic[]; +>getSyntacticDiagnostics : (fileName: string) => Diagnostic[] +>fileName : string +>Diagnostic : Diagnostic + + getSemanticDiagnostics(fileName: string): Diagnostic[]; +>getSemanticDiagnostics : (fileName: string) => Diagnostic[] +>fileName : string +>Diagnostic : Diagnostic + + getCompilerOptionsDiagnostics(): Diagnostic[]; +>getCompilerOptionsDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; +>getSyntacticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[] +>fileName : string +>span : TextSpan +>TextSpan : TextSpan +>ClassifiedSpan : ClassifiedSpan + + getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; +>getSemanticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[] +>fileName : string +>span : TextSpan +>TextSpan : TextSpan +>ClassifiedSpan : ClassifiedSpan + + getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; +>getCompletionsAtPosition : (fileName: string, position: number, isMemberCompletion: boolean) => CompletionInfo +>fileName : string +>position : number +>isMemberCompletion : boolean +>CompletionInfo : CompletionInfo + + getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; +>getCompletionEntryDetails : (fileName: string, position: number, entryName: string) => CompletionEntryDetails +>fileName : string +>position : number +>entryName : string +>CompletionEntryDetails : CompletionEntryDetails + + getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; +>getQuickInfoAtPosition : (fileName: string, position: number) => QuickInfo +>fileName : string +>position : number +>QuickInfo : QuickInfo + + getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan; +>getNameOrDottedNameSpan : (fileName: string, startPos: number, endPos: number) => TextSpan +>fileName : string +>startPos : number +>endPos : number +>TextSpan : TextSpan + + getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan; +>getBreakpointStatementAtPosition : (fileName: string, position: number) => TextSpan +>fileName : string +>position : number +>TextSpan : TextSpan + + getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems; +>getSignatureHelpItems : (fileName: string, position: number) => SignatureHelpItems +>fileName : string +>position : number +>SignatureHelpItems : SignatureHelpItems + + getRenameInfo(fileName: string, position: number): RenameInfo; +>getRenameInfo : (fileName: string, position: number) => RenameInfo +>fileName : string +>position : number +>RenameInfo : RenameInfo + + findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[]; +>findRenameLocations : (fileName: string, position: number, findInStrings: boolean, findInComments: boolean) => RenameLocation[] +>fileName : string +>position : number +>findInStrings : boolean +>findInComments : boolean +>RenameLocation : RenameLocation + + getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[]; +>getDefinitionAtPosition : (fileName: string, position: number) => DefinitionInfo[] +>fileName : string +>position : number +>DefinitionInfo : DefinitionInfo + + getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[]; +>getReferencesAtPosition : (fileName: string, position: number) => ReferenceEntry[] +>fileName : string +>position : number +>ReferenceEntry : ReferenceEntry + + getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[]; +>getOccurrencesAtPosition : (fileName: string, position: number) => ReferenceEntry[] +>fileName : string +>position : number +>ReferenceEntry : ReferenceEntry + + getNavigateToItems(searchValue: string): NavigateToItem[]; +>getNavigateToItems : (searchValue: string) => NavigateToItem[] +>searchValue : string +>NavigateToItem : NavigateToItem + + getNavigationBarItems(fileName: string): NavigationBarItem[]; +>getNavigationBarItems : (fileName: string) => NavigationBarItem[] +>fileName : string +>NavigationBarItem : NavigationBarItem + + getOutliningSpans(fileName: string): OutliningSpan[]; +>getOutliningSpans : (fileName: string) => OutliningSpan[] +>fileName : string +>OutliningSpan : OutliningSpan + + getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[]; +>getTodoComments : (fileName: string, descriptors: TodoCommentDescriptor[]) => TodoComment[] +>fileName : string +>descriptors : TodoCommentDescriptor[] +>TodoCommentDescriptor : TodoCommentDescriptor +>TodoComment : TodoComment + + getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[]; +>getBraceMatchingAtPosition : (fileName: string, position: number) => TextSpan[] +>fileName : string +>position : number +>TextSpan : TextSpan + + getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number; +>getIndentationAtPosition : (fileName: string, position: number, options: EditorOptions) => number +>fileName : string +>position : number +>options : EditorOptions +>EditorOptions : EditorOptions + + getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[]; +>getFormattingEditsForRange : (fileName: string, start: number, end: number, options: FormatCodeOptions) => TextChange[] +>fileName : string +>start : number +>end : number +>options : FormatCodeOptions +>FormatCodeOptions : FormatCodeOptions +>TextChange : TextChange + + getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[]; +>getFormattingEditsForDocument : (fileName: string, options: FormatCodeOptions) => TextChange[] +>fileName : string +>options : FormatCodeOptions +>FormatCodeOptions : FormatCodeOptions +>TextChange : TextChange + + getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[]; +>getFormattingEditsAfterKeystroke : (fileName: string, position: number, key: string, options: FormatCodeOptions) => TextChange[] +>fileName : string +>position : number +>key : string +>options : FormatCodeOptions +>FormatCodeOptions : FormatCodeOptions +>TextChange : TextChange + + getEmitOutput(fileName: string): EmitOutput; +>getEmitOutput : (fileName: string) => EmitOutput +>fileName : string +>EmitOutput : EmitOutput + + getSourceFile(filename: string): SourceFile; +>getSourceFile : (filename: string) => SourceFile +>filename : string +>SourceFile : SourceFile + + dispose(): void; +>dispose : () => void + } + class TextSpan { +>TextSpan : TextSpan + + private _start; +>_start : any + + private _length; +>_length : any + + /** + * Creates a TextSpan instance beginning with the position Start and having the Length + * specified with length. + */ + constructor(start: number, length: number); +>start : number +>length : number + + toJSON(key: any): any; +>toJSON : (key: any) => any +>key : any + + start(): number; +>start : () => number + + length(): number; +>length : () => number + + end(): number; +>end : () => number + + isEmpty(): boolean; +>isEmpty : () => boolean + + /** + * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less + * than End, otherwise false. + * @param position The position to check. + */ + containsPosition(position: number): boolean; +>containsPosition : (position: number) => boolean +>position : number + + /** + * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false. + * @param span The span to check. + */ + containsTextSpan(span: TextSpan): boolean; +>containsTextSpan : (span: TextSpan) => boolean +>span : TextSpan +>TextSpan : TextSpan + + /** + * Determines whether the given span overlaps this span. Two spans are considered to overlap + * if they have positions in common and neither is empty. Empty spans do not overlap with any + * other span. Returns true if the spans overlap, false otherwise. + * @param span The span to check. + */ + overlapsWith(span: TextSpan): boolean; +>overlapsWith : (span: TextSpan) => boolean +>span : TextSpan +>TextSpan : TextSpan + + /** + * Returns the overlap with the given span, or undefined if there is no overlap. + * @param span The span to check. + */ + overlap(span: TextSpan): TextSpan; +>overlap : (span: TextSpan) => TextSpan +>span : TextSpan +>TextSpan : TextSpan +>TextSpan : TextSpan + + /** + * Determines whether span intersects this span. Two spans are considered to + * intersect if they have positions in common or the end of one span + * coincides with the start of the other span. Returns true if the spans intersect, false otherwise. + * @param The span to check. + */ + intersectsWithTextSpan(span: TextSpan): boolean; +>intersectsWithTextSpan : (span: TextSpan) => boolean +>span : TextSpan +>TextSpan : TextSpan + + intersectsWith(start: number, length: number): boolean; +>intersectsWith : (start: number, length: number) => boolean +>start : number +>length : number + + /** + * Determines whether the given position intersects this span. + * A position is considered to intersect if it is between the start and + * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise. + * @param position The position to check. + */ + intersectsWithPosition(position: number): boolean; +>intersectsWithPosition : (position: number) => boolean +>position : number + + /** + * Returns the intersection with the given span, or undefined if there is no intersection. + * @param span The span to check. + */ + intersection(span: TextSpan): TextSpan; +>intersection : (span: TextSpan) => TextSpan +>span : TextSpan +>TextSpan : TextSpan +>TextSpan : TextSpan + + /** + * Creates a new TextSpan from the given start and end positions + * as opposed to a position and length. + */ + static fromBounds(start: number, end: number): TextSpan; +>fromBounds : (start: number, end: number) => TextSpan +>start : number +>end : number +>TextSpan : TextSpan + } + class TextChangeRange { +>TextChangeRange : TextChangeRange + + static unchanged: TextChangeRange; +>unchanged : TextChangeRange +>TextChangeRange : TextChangeRange + + private _span; +>_span : any + + private _newLength; +>_newLength : any + + /** + * Initializes a new instance of TextChangeRange. + */ + constructor(span: TextSpan, newLength: number); +>span : TextSpan +>TextSpan : TextSpan +>newLength : number + + /** + * The span of text before the edit which is being changed + */ + span(): TextSpan; +>span : () => TextSpan +>TextSpan : TextSpan + + /** + * Width of the span after the edit. A 0 here would represent a delete + */ + newLength(): number; +>newLength : () => number + + newSpan(): TextSpan; +>newSpan : () => TextSpan +>TextSpan : TextSpan + + isUnchanged(): boolean; +>isUnchanged : () => boolean + + /** + * Called to merge all the changes that occurred across several versions of a script snapshot + * into a single change. i.e. if a user keeps making successive edits to a script we will + * have a text change from V1 to V2, V2 to V3, ..., Vn. + * + * This function will then merge those changes into a single change range valid between V1 and + * Vn. + */ + static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; +>collapseChangesAcrossMultipleVersions : (changes: TextChangeRange[]) => TextChangeRange +>changes : TextChangeRange[] +>TextChangeRange : TextChangeRange +>TextChangeRange : TextChangeRange + } + interface ClassifiedSpan { +>ClassifiedSpan : ClassifiedSpan + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + classificationType: string; +>classificationType : string + } + interface NavigationBarItem { +>NavigationBarItem : NavigationBarItem + + text: string; +>text : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + spans: TextSpan[]; +>spans : TextSpan[] +>TextSpan : TextSpan + + childItems: NavigationBarItem[]; +>childItems : NavigationBarItem[] +>NavigationBarItem : NavigationBarItem + + indent: number; +>indent : number + + bolded: boolean; +>bolded : boolean + + grayed: boolean; +>grayed : boolean + } + interface TodoCommentDescriptor { +>TodoCommentDescriptor : TodoCommentDescriptor + + text: string; +>text : string + + priority: number; +>priority : number + } + interface TodoComment { +>TodoComment : TodoComment + + descriptor: TodoCommentDescriptor; +>descriptor : TodoCommentDescriptor +>TodoCommentDescriptor : TodoCommentDescriptor + + message: string; +>message : string + + position: number; +>position : number + } + class TextChange { +>TextChange : TextChange + + span: TextSpan; +>span : TextSpan +>TextSpan : TextSpan + + newText: string; +>newText : string + } + interface RenameLocation { +>RenameLocation : RenameLocation + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + fileName: string; +>fileName : string + } + interface ReferenceEntry { +>ReferenceEntry : ReferenceEntry + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + fileName: string; +>fileName : string + + isWriteAccess: boolean; +>isWriteAccess : boolean + } + interface NavigateToItem { +>NavigateToItem : NavigateToItem + + name: string; +>name : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + matchKind: string; +>matchKind : string + + fileName: string; +>fileName : string + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + containerName: string; +>containerName : string + + containerKind: string; +>containerKind : string + } + interface EditorOptions { +>EditorOptions : EditorOptions + + IndentSize: number; +>IndentSize : number + + TabSize: number; +>TabSize : number + + NewLineCharacter: string; +>NewLineCharacter : string + + ConvertTabsToSpaces: boolean; +>ConvertTabsToSpaces : boolean + } + interface FormatCodeOptions extends EditorOptions { +>FormatCodeOptions : FormatCodeOptions +>EditorOptions : EditorOptions + + InsertSpaceAfterCommaDelimiter: boolean; +>InsertSpaceAfterCommaDelimiter : boolean + + InsertSpaceAfterSemicolonInForStatements: boolean; +>InsertSpaceAfterSemicolonInForStatements : boolean + + InsertSpaceBeforeAndAfterBinaryOperators: boolean; +>InsertSpaceBeforeAndAfterBinaryOperators : boolean + + InsertSpaceAfterKeywordsInControlFlowStatements: boolean; +>InsertSpaceAfterKeywordsInControlFlowStatements : boolean + + InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean; +>InsertSpaceAfterFunctionKeywordForAnonymousFunctions : boolean + + InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean; +>InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis : boolean + + PlaceOpenBraceOnNewLineForFunctions: boolean; +>PlaceOpenBraceOnNewLineForFunctions : boolean + + PlaceOpenBraceOnNewLineForControlBlocks: boolean; +>PlaceOpenBraceOnNewLineForControlBlocks : boolean + } + interface DefinitionInfo { +>DefinitionInfo : DefinitionInfo + + fileName: string; +>fileName : string + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + kind: string; +>kind : string + + name: string; +>name : string + + containerKind: string; +>containerKind : string + + containerName: string; +>containerName : string + } + enum SymbolDisplayPartKind { +>SymbolDisplayPartKind : SymbolDisplayPartKind + + aliasName = 0, +>aliasName : SymbolDisplayPartKind + + className = 1, +>className : SymbolDisplayPartKind + + enumName = 2, +>enumName : SymbolDisplayPartKind + + fieldName = 3, +>fieldName : SymbolDisplayPartKind + + interfaceName = 4, +>interfaceName : SymbolDisplayPartKind + + keyword = 5, +>keyword : SymbolDisplayPartKind + + lineBreak = 6, +>lineBreak : SymbolDisplayPartKind + + numericLiteral = 7, +>numericLiteral : SymbolDisplayPartKind + + stringLiteral = 8, +>stringLiteral : SymbolDisplayPartKind + + localName = 9, +>localName : SymbolDisplayPartKind + + methodName = 10, +>methodName : SymbolDisplayPartKind + + moduleName = 11, +>moduleName : SymbolDisplayPartKind + + operator = 12, +>operator : SymbolDisplayPartKind + + parameterName = 13, +>parameterName : SymbolDisplayPartKind + + propertyName = 14, +>propertyName : SymbolDisplayPartKind + + punctuation = 15, +>punctuation : SymbolDisplayPartKind + + space = 16, +>space : SymbolDisplayPartKind + + text = 17, +>text : SymbolDisplayPartKind + + typeParameterName = 18, +>typeParameterName : SymbolDisplayPartKind + + enumMemberName = 19, +>enumMemberName : SymbolDisplayPartKind + + functionName = 20, +>functionName : SymbolDisplayPartKind + + regularExpressionLiteral = 21, +>regularExpressionLiteral : SymbolDisplayPartKind + } + interface SymbolDisplayPart { +>SymbolDisplayPart : SymbolDisplayPart + + text: string; +>text : string + + kind: string; +>kind : string + } + interface QuickInfo { +>QuickInfo : QuickInfo + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + displayParts: SymbolDisplayPart[]; +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface RenameInfo { +>RenameInfo : RenameInfo + + canRename: boolean; +>canRename : boolean + + localizedErrorMessage: string; +>localizedErrorMessage : string + + displayName: string; +>displayName : string + + fullDisplayName: string; +>fullDisplayName : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + triggerSpan: TextSpan; +>triggerSpan : TextSpan +>TextSpan : TextSpan + } + interface SignatureHelpParameter { +>SignatureHelpParameter : SignatureHelpParameter + + name: string; +>name : string + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + displayParts: SymbolDisplayPart[]; +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + isOptional: boolean; +>isOptional : boolean + } + /** + * Represents a single signature to show in signature help. + * The id is used for subsequent calls into the language service to ask questions about the + * signature help item in the context of any documents that have been updated. i.e. after + * an edit has happened, while signature help is still active, the host can ask important + * questions like 'what parameter is the user currently contained within?'. + */ + interface SignatureHelpItem { +>SignatureHelpItem : SignatureHelpItem + + isVariadic: boolean; +>isVariadic : boolean + + prefixDisplayParts: SymbolDisplayPart[]; +>prefixDisplayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + suffixDisplayParts: SymbolDisplayPart[]; +>suffixDisplayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + separatorDisplayParts: SymbolDisplayPart[]; +>separatorDisplayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + parameters: SignatureHelpParameter[]; +>parameters : SignatureHelpParameter[] +>SignatureHelpParameter : SignatureHelpParameter + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + /** + * Represents a set of signature help items, and the preferred item that should be selected. + */ + interface SignatureHelpItems { +>SignatureHelpItems : SignatureHelpItems + + items: SignatureHelpItem[]; +>items : SignatureHelpItem[] +>SignatureHelpItem : SignatureHelpItem + + applicableSpan: TextSpan; +>applicableSpan : TextSpan +>TextSpan : TextSpan + + selectedItemIndex: number; +>selectedItemIndex : number + + argumentIndex: number; +>argumentIndex : number + + argumentCount: number; +>argumentCount : number + } + interface CompletionInfo { +>CompletionInfo : CompletionInfo + + isMemberCompletion: boolean; +>isMemberCompletion : boolean + + entries: CompletionEntry[]; +>entries : CompletionEntry[] +>CompletionEntry : CompletionEntry + } + interface CompletionEntry { +>CompletionEntry : CompletionEntry + + name: string; +>name : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + } + interface CompletionEntryDetails { +>CompletionEntryDetails : CompletionEntryDetails + + name: string; +>name : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + displayParts: SymbolDisplayPart[]; +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface OutliningSpan { +>OutliningSpan : OutliningSpan + + /** The span of the document to actually collapse. */ + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + /** The span of the document to display when the user hovers over the collapsed span. */ + hintSpan: TextSpan; +>hintSpan : TextSpan +>TextSpan : TextSpan + + /** The text to display in the editor for the collapsed region. */ + bannerText: string; +>bannerText : string + + /** + * Whether or not this region should be automatically collapsed when + * the 'Collapse to Definitions' command is invoked. + */ + autoCollapse: boolean; +>autoCollapse : boolean + } + interface EmitOutput { +>EmitOutput : EmitOutput + + outputFiles: OutputFile[]; +>outputFiles : OutputFile[] +>OutputFile : OutputFile + + emitOutputStatus: EmitReturnStatus; +>emitOutputStatus : EmitReturnStatus +>EmitReturnStatus : EmitReturnStatus + } + const enum OutputFileType { +>OutputFileType : OutputFileType + + JavaScript = 0, +>JavaScript : OutputFileType + + SourceMap = 1, +>SourceMap : OutputFileType + + Declaration = 2, +>Declaration : OutputFileType + } + interface OutputFile { +>OutputFile : OutputFile + + name: string; +>name : string + + writeByteOrderMark: boolean; +>writeByteOrderMark : boolean + + text: string; +>text : string + } + const enum EndOfLineState { +>EndOfLineState : EndOfLineState + + Start = 0, +>Start : EndOfLineState + + InMultiLineCommentTrivia = 1, +>InMultiLineCommentTrivia : EndOfLineState + + InSingleQuoteStringLiteral = 2, +>InSingleQuoteStringLiteral : EndOfLineState + + InDoubleQuoteStringLiteral = 3, +>InDoubleQuoteStringLiteral : EndOfLineState + } + enum TokenClass { +>TokenClass : TokenClass + + Punctuation = 0, +>Punctuation : TokenClass + + Keyword = 1, +>Keyword : TokenClass + + Operator = 2, +>Operator : TokenClass + + Comment = 3, +>Comment : TokenClass + + Whitespace = 4, +>Whitespace : TokenClass + + Identifier = 5, +>Identifier : TokenClass + + NumberLiteral = 6, +>NumberLiteral : TokenClass + + StringLiteral = 7, +>StringLiteral : TokenClass + + RegExpLiteral = 8, +>RegExpLiteral : TokenClass + } + interface ClassificationResult { +>ClassificationResult : ClassificationResult + + finalLexState: EndOfLineState; +>finalLexState : EndOfLineState +>EndOfLineState : EndOfLineState + + entries: ClassificationInfo[]; +>entries : ClassificationInfo[] +>ClassificationInfo : ClassificationInfo + } + interface ClassificationInfo { +>ClassificationInfo : ClassificationInfo + + length: number; +>length : number + + classification: TokenClass; +>classification : TokenClass +>TokenClass : TokenClass + } + interface Classifier { +>Classifier : Classifier + + getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult; +>getClassificationsForLine : (text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean) => ClassificationResult +>text : string +>lexState : EndOfLineState +>EndOfLineState : EndOfLineState +>classifyKeywordsInGenerics : boolean +>ClassificationResult : ClassificationResult + } + interface DocumentRegistry { +>DocumentRegistry : DocumentRegistry + + acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile; +>acquireDocument : (filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean) => SourceFile +>filename : string +>compilationSettings : CompilerOptions +>CompilerOptions : CompilerOptions +>scriptSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>version : string +>isOpen : boolean +>SourceFile : SourceFile + + updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; +>updateDocument : (sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile +>sourceFile : SourceFile +>SourceFile : SourceFile +>filename : string +>compilationSettings : CompilerOptions +>CompilerOptions : CompilerOptions +>scriptSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>version : string +>isOpen : boolean +>textChangeRange : TextChangeRange +>TextChangeRange : TextChangeRange +>SourceFile : SourceFile + + releaseDocument(filename: string, compilationSettings: CompilerOptions): void; +>releaseDocument : (filename: string, compilationSettings: CompilerOptions) => void +>filename : string +>compilationSettings : CompilerOptions +>CompilerOptions : CompilerOptions + } + class ScriptElementKind { +>ScriptElementKind : ScriptElementKind + + static unknown: string; +>unknown : string + + static keyword: string; +>keyword : string + + static scriptElement: string; +>scriptElement : string + + static moduleElement: string; +>moduleElement : string + + static classElement: string; +>classElement : string + + static interfaceElement: string; +>interfaceElement : string + + static typeElement: string; +>typeElement : string + + static enumElement: string; +>enumElement : string + + static variableElement: string; +>variableElement : string + + static localVariableElement: string; +>localVariableElement : string + + static functionElement: string; +>functionElement : string + + static localFunctionElement: string; +>localFunctionElement : string + + static memberFunctionElement: string; +>memberFunctionElement : string + + static memberGetAccessorElement: string; +>memberGetAccessorElement : string + + static memberSetAccessorElement: string; +>memberSetAccessorElement : string + + static memberVariableElement: string; +>memberVariableElement : string + + static constructorImplementationElement: string; +>constructorImplementationElement : string + + static callSignatureElement: string; +>callSignatureElement : string + + static indexSignatureElement: string; +>indexSignatureElement : string + + static constructSignatureElement: string; +>constructSignatureElement : string + + static parameterElement: string; +>parameterElement : string + + static typeParameterElement: string; +>typeParameterElement : string + + static primitiveType: string; +>primitiveType : string + + static label: string; +>label : string + + static alias: string; +>alias : string + + static constElement: string; +>constElement : string + + static letElement: string; +>letElement : string + } + class ScriptElementKindModifier { +>ScriptElementKindModifier : ScriptElementKindModifier + + static none: string; +>none : string + + static publicMemberModifier: string; +>publicMemberModifier : string + + static privateMemberModifier: string; +>privateMemberModifier : string + + static protectedMemberModifier: string; +>protectedMemberModifier : string + + static exportedModifier: string; +>exportedModifier : string + + static ambientModifier: string; +>ambientModifier : string + + static staticModifier: string; +>staticModifier : string + } + class ClassificationTypeNames { +>ClassificationTypeNames : ClassificationTypeNames + + static comment: string; +>comment : string + + static identifier: string; +>identifier : string + + static keyword: string; +>keyword : string + + static numericLiteral: string; +>numericLiteral : string + + static operator: string; +>operator : string + + static stringLiteral: string; +>stringLiteral : string + + static whiteSpace: string; +>whiteSpace : string + + static text: string; +>text : string + + static punctuation: string; +>punctuation : string + + static className: string; +>className : string + + static enumName: string; +>enumName : string + + static interfaceName: string; +>interfaceName : string + + static moduleName: string; +>moduleName : string + + static typeParameterName: string; +>typeParameterName : string + } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; +>displayPartsToString : (displayParts: SymbolDisplayPart[]) => string +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + interface DisplayPartsSymbolWriter extends SymbolWriter { +>DisplayPartsSymbolWriter : DisplayPartsSymbolWriter +>SymbolWriter : SymbolWriter + + displayParts(): SymbolDisplayPart[]; +>displayParts : () => SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + function getDefaultCompilerOptions(): CompilerOptions; +>getDefaultCompilerOptions : () => CompilerOptions +>CompilerOptions : CompilerOptions + + class OperationCanceledException { +>OperationCanceledException : OperationCanceledException + } + class CancellationTokenObject { +>CancellationTokenObject : CancellationTokenObject + + private cancellationToken; +>cancellationToken : any + + static None: CancellationTokenObject; +>None : CancellationTokenObject +>CancellationTokenObject : CancellationTokenObject + + constructor(cancellationToken: CancellationToken); +>cancellationToken : CancellationToken +>CancellationToken : CancellationToken + + isCancellationRequested(): boolean; +>isCancellationRequested : () => boolean + + throwIfCancellationRequested(): void; +>throwIfCancellationRequested : () => void + } + function createDocumentRegistry(): DocumentRegistry; +>createDocumentRegistry : () => DocumentRegistry +>DocumentRegistry : DocumentRegistry + + function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; +>preProcessFile : (sourceText: string, readImportFiles?: boolean) => PreProcessedFileInfo +>sourceText : string +>readImportFiles : boolean +>PreProcessedFileInfo : PreProcessedFileInfo + + function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService; +>createLanguageService : (host: LanguageServiceHost, documentRegistry: DocumentRegistry) => LanguageService +>host : LanguageServiceHost +>LanguageServiceHost : LanguageServiceHost +>documentRegistry : DocumentRegistry +>DocumentRegistry : DocumentRegistry +>LanguageService : LanguageService + + function createClassifier(host: Logger): Classifier; +>createClassifier : (host: Logger) => Classifier +>host : Logger +>Logger : Logger +>Classifier : Classifier +} + +export = ts; +>ts : typeof ts + diff --git a/tests/baselines/reference/APISample_standalone_compile.js b/tests/baselines/reference/APISample_standalone_compile.js new file mode 100644 index 0000000000000..e1f55f8a4c221 --- /dev/null +++ b/tests/baselines/reference/APISample_standalone_compile.js @@ -0,0 +1,1836 @@ +//// [tests/cases/compiler/APISample_standalone_compile.ts] //// + +//// [APISample_standalone_compile.ts] + +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0"); + +var program = ts.createProgram(["file1.ts"], {}, undefined); +//// [typescriptServices.d.ts] +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +declare module ts { + interface Map { + [index: string]: T; + } + interface TextRange { + pos: number; + end: number; + } + const enum SyntaxKind { + Unknown = 0, + EndOfFileToken = 1, + SingleLineCommentTrivia = 2, + MultiLineCommentTrivia = 3, + NewLineTrivia = 4, + WhitespaceTrivia = 5, + NumericLiteral = 6, + StringLiteral = 7, + RegularExpressionLiteral = 8, + NoSubstitutionTemplateLiteral = 9, + TemplateHead = 10, + TemplateMiddle = 11, + TemplateTail = 12, + OpenBraceToken = 13, + CloseBraceToken = 14, + OpenParenToken = 15, + CloseParenToken = 16, + OpenBracketToken = 17, + CloseBracketToken = 18, + DotToken = 19, + DotDotDotToken = 20, + SemicolonToken = 21, + CommaToken = 22, + LessThanToken = 23, + GreaterThanToken = 24, + LessThanEqualsToken = 25, + GreaterThanEqualsToken = 26, + EqualsEqualsToken = 27, + ExclamationEqualsToken = 28, + EqualsEqualsEqualsToken = 29, + ExclamationEqualsEqualsToken = 30, + EqualsGreaterThanToken = 31, + PlusToken = 32, + MinusToken = 33, + AsteriskToken = 34, + SlashToken = 35, + PercentToken = 36, + PlusPlusToken = 37, + MinusMinusToken = 38, + LessThanLessThanToken = 39, + GreaterThanGreaterThanToken = 40, + GreaterThanGreaterThanGreaterThanToken = 41, + AmpersandToken = 42, + BarToken = 43, + CaretToken = 44, + ExclamationToken = 45, + TildeToken = 46, + AmpersandAmpersandToken = 47, + BarBarToken = 48, + QuestionToken = 49, + ColonToken = 50, + EqualsToken = 51, + PlusEqualsToken = 52, + MinusEqualsToken = 53, + AsteriskEqualsToken = 54, + SlashEqualsToken = 55, + PercentEqualsToken = 56, + LessThanLessThanEqualsToken = 57, + GreaterThanGreaterThanEqualsToken = 58, + GreaterThanGreaterThanGreaterThanEqualsToken = 59, + AmpersandEqualsToken = 60, + BarEqualsToken = 61, + CaretEqualsToken = 62, + Identifier = 63, + BreakKeyword = 64, + CaseKeyword = 65, + CatchKeyword = 66, + ClassKeyword = 67, + ConstKeyword = 68, + ContinueKeyword = 69, + DebuggerKeyword = 70, + DefaultKeyword = 71, + DeleteKeyword = 72, + DoKeyword = 73, + ElseKeyword = 74, + EnumKeyword = 75, + ExportKeyword = 76, + ExtendsKeyword = 77, + FalseKeyword = 78, + FinallyKeyword = 79, + ForKeyword = 80, + FunctionKeyword = 81, + IfKeyword = 82, + ImportKeyword = 83, + InKeyword = 84, + InstanceOfKeyword = 85, + NewKeyword = 86, + NullKeyword = 87, + ReturnKeyword = 88, + SuperKeyword = 89, + SwitchKeyword = 90, + ThisKeyword = 91, + ThrowKeyword = 92, + TrueKeyword = 93, + TryKeyword = 94, + TypeOfKeyword = 95, + VarKeyword = 96, + VoidKeyword = 97, + WhileKeyword = 98, + WithKeyword = 99, + ImplementsKeyword = 100, + InterfaceKeyword = 101, + LetKeyword = 102, + PackageKeyword = 103, + PrivateKeyword = 104, + ProtectedKeyword = 105, + PublicKeyword = 106, + StaticKeyword = 107, + YieldKeyword = 108, + AnyKeyword = 109, + BooleanKeyword = 110, + ConstructorKeyword = 111, + DeclareKeyword = 112, + GetKeyword = 113, + ModuleKeyword = 114, + RequireKeyword = 115, + NumberKeyword = 116, + SetKeyword = 117, + StringKeyword = 118, + TypeKeyword = 119, + Missing = 120, + QualifiedName = 121, + ComputedPropertyName = 122, + TypeParameter = 123, + Parameter = 124, + Property = 125, + Method = 126, + Constructor = 127, + GetAccessor = 128, + SetAccessor = 129, + CallSignature = 130, + ConstructSignature = 131, + IndexSignature = 132, + TypeReference = 133, + FunctionType = 134, + ConstructorType = 135, + TypeQuery = 136, + TypeLiteral = 137, + ArrayType = 138, + TupleType = 139, + UnionType = 140, + ParenthesizedType = 141, + ArrayLiteralExpression = 142, + ObjectLiteralExpression = 143, + PropertyAccessExpression = 144, + ElementAccessExpression = 145, + CallExpression = 146, + NewExpression = 147, + TaggedTemplateExpression = 148, + TypeAssertionExpression = 149, + ParenthesizedExpression = 150, + FunctionExpression = 151, + ArrowFunction = 152, + DeleteExpression = 153, + TypeOfExpression = 154, + VoidExpression = 155, + PrefixUnaryExpression = 156, + PostfixUnaryExpression = 157, + BinaryExpression = 158, + ConditionalExpression = 159, + TemplateExpression = 160, + YieldExpression = 161, + OmittedExpression = 162, + TemplateSpan = 163, + Block = 164, + VariableStatement = 165, + EmptyStatement = 166, + ExpressionStatement = 167, + IfStatement = 168, + DoStatement = 169, + WhileStatement = 170, + ForStatement = 171, + ForInStatement = 172, + ContinueStatement = 173, + BreakStatement = 174, + ReturnStatement = 175, + WithStatement = 176, + SwitchStatement = 177, + LabeledStatement = 178, + ThrowStatement = 179, + TryStatement = 180, + TryBlock = 181, + CatchBlock = 182, + FinallyBlock = 183, + DebuggerStatement = 184, + VariableDeclaration = 185, + FunctionDeclaration = 186, + FunctionBlock = 187, + ClassDeclaration = 188, + InterfaceDeclaration = 189, + TypeAliasDeclaration = 190, + EnumDeclaration = 191, + ModuleDeclaration = 192, + ModuleBlock = 193, + ImportDeclaration = 194, + ExportAssignment = 195, + CaseClause = 196, + DefaultClause = 197, + HeritageClause = 198, + PropertyAssignment = 199, + ShorthandPropertyAssignment = 200, + EnumMember = 201, + SourceFile = 202, + Program = 203, + SyntaxList = 204, + Count = 205, + FirstAssignment = 51, + LastAssignment = 62, + FirstReservedWord = 64, + LastReservedWord = 99, + FirstKeyword = 64, + LastKeyword = 119, + FirstFutureReservedWord = 100, + LastFutureReservedWord = 108, + FirstTypeNode = 133, + LastTypeNode = 141, + FirstPunctuation = 13, + LastPunctuation = 62, + FirstToken = 1, + LastToken = 119, + FirstTriviaToken = 2, + LastTriviaToken = 5, + FirstLiteralToken = 6, + LastLiteralToken = 9, + FirstTemplateToken = 9, + LastTemplateToken = 12, + FirstOperator = 21, + LastOperator = 62, + FirstBinaryOperator = 23, + LastBinaryOperator = 62, + } + const enum NodeFlags { + Export = 1, + Ambient = 2, + QuestionMark = 4, + Rest = 8, + Public = 16, + Private = 32, + Protected = 64, + Static = 128, + MultiLine = 256, + Synthetic = 512, + DeclarationFile = 1024, + Let = 2048, + Const = 4096, + OctalLiteral = 8192, + Modifier = 243, + AccessibilityModifier = 112, + BlockScoped = 6144, + } + const enum ParserContextFlags { + StrictMode = 1, + DisallowIn = 2, + Yield = 4, + GeneratorParameter = 8, + } + interface Node extends TextRange { + kind: SyntaxKind; + flags: NodeFlags; + parserContextFlags?: ParserContextFlags; + id?: number; + parent?: Node; + symbol?: Symbol; + locals?: SymbolTable; + nextContainer?: Node; + localSymbol?: Symbol; + modifiers?: ModifiersArray; + } + interface NodeArray extends Array, TextRange { + hasTrailingComma?: boolean; + } + interface ModifiersArray extends Array { + flags: number; + } + interface Identifier extends PrimaryExpression { + text: string; + } + interface QualifiedName extends Node { + left: EntityName; + right: Identifier; + } + type EntityName = Identifier | QualifiedName; + interface ParsedSignature { + typeParameters?: NodeArray; + parameters: NodeArray; + type?: TypeNode; + } + type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; + interface Declaration extends Node { + _declarationBrand: any; + name?: DeclarationName; + } + interface ComputedPropertyName extends Node { + expression: Expression; + } + interface TypeParameterDeclaration extends Declaration { + name: Identifier; + constraint?: TypeNode; + expression?: Expression; + } + interface SignatureDeclaration extends Declaration, ParsedSignature { + } + interface VariableDeclaration extends Declaration { + name: Identifier; + type?: TypeNode; + initializer?: Expression; + } + interface PropertyDeclaration extends Declaration, ClassElement { + type?: TypeNode; + initializer?: Expression; + } + interface ShortHandPropertyDeclaration extends Declaration { + name: Identifier; + } + interface ParameterDeclaration extends VariableDeclaration { + } + /** + * Several node kinds share function-like features such as a signature, + * a name, and a body. These nodes should extend FunctionLikeDeclaration. + * Examples: + * FunctionDeclaration + * MethodDeclaration + * AccessorDeclaration + */ + interface FunctionLikeDeclaration extends SignatureDeclaration { + _functionLikeDeclarationBrand: any; + asteriskToken?: Node; + body?: Block | Expression; + } + interface FunctionDeclaration extends FunctionLikeDeclaration, Statement { + name: Identifier; + body?: Block; + } + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { + body?: Block; + } + interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement { + body?: Block; + } + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { + body?: Block; + } + interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement { + _indexSignatureDeclarationBrand: any; + } + interface TypeNode extends Node { + } + interface TypeReferenceNode extends TypeNode { + typeName: EntityName; + typeArguments?: NodeArray; + } + interface TypeQueryNode extends TypeNode { + exprName: EntityName; + } + interface TypeLiteralNode extends TypeNode, Declaration { + members: NodeArray; + } + interface ArrayTypeNode extends TypeNode { + elementType: TypeNode; + } + interface TupleTypeNode extends TypeNode { + elementTypes: NodeArray; + } + interface UnionTypeNode extends TypeNode { + types: NodeArray; + } + interface ParenthesizedTypeNode extends TypeNode { + type: TypeNode; + } + interface StringLiteralTypeNode extends TypeNode { + text: string; + } + interface Expression extends Node { + _expressionBrand: any; + contextualType?: Type; + } + interface UnaryExpression extends Expression { + _unaryExpressionBrand: any; + } + interface PrefixUnaryExpression extends UnaryExpression { + operator: SyntaxKind; + operand: UnaryExpression; + } + interface PostfixUnaryExpression extends PostfixExpression { + operand: LeftHandSideExpression; + operator: SyntaxKind; + } + interface PostfixExpression extends UnaryExpression { + _postfixExpressionBrand: any; + } + interface LeftHandSideExpression extends PostfixExpression { + _leftHandSideExpressionBrand: any; + } + interface MemberExpression extends LeftHandSideExpression { + _memberExpressionBrand: any; + } + interface PrimaryExpression extends MemberExpression { + _primaryExpressionBrand: any; + } + interface DeleteExpression extends UnaryExpression { + expression: UnaryExpression; + } + interface TypeOfExpression extends UnaryExpression { + expression: UnaryExpression; + } + interface VoidExpression extends UnaryExpression { + expression: UnaryExpression; + } + interface YieldExpression extends Expression { + asteriskToken?: Node; + expression: Expression; + } + interface BinaryExpression extends Expression { + left: Expression; + operator: SyntaxKind; + right: Expression; + } + interface ConditionalExpression extends Expression { + condition: Expression; + whenTrue: Expression; + whenFalse: Expression; + } + interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration { + name?: Identifier; + body: Block | Expression; + } + interface LiteralExpression extends PrimaryExpression { + text: string; + } + interface TemplateExpression extends PrimaryExpression { + head: LiteralExpression; + templateSpans: NodeArray; + } + interface TemplateSpan extends Node { + expression: Expression; + literal: LiteralExpression; + } + interface ParenthesizedExpression extends PrimaryExpression { + expression: Expression; + } + interface ArrayLiteralExpression extends PrimaryExpression { + elements: NodeArray; + } + interface ObjectLiteralExpression extends PrimaryExpression, Declaration { + properties: NodeArray; + } + interface PropertyAccessExpression extends MemberExpression { + expression: LeftHandSideExpression; + name: Identifier; + } + interface ElementAccessExpression extends MemberExpression { + expression: LeftHandSideExpression; + argumentExpression: Expression; + } + interface CallExpression extends LeftHandSideExpression { + expression: LeftHandSideExpression; + typeArguments?: NodeArray; + arguments: NodeArray; + } + interface NewExpression extends CallExpression, PrimaryExpression { + } + interface TaggedTemplateExpression extends MemberExpression { + tag: LeftHandSideExpression; + template: LiteralExpression | TemplateExpression; + } + type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; + interface TypeAssertion extends UnaryExpression { + type: TypeNode; + expression: UnaryExpression; + } + interface Statement extends Node, ModuleElement { + _statementBrand: any; + } + interface Block extends Statement { + statements: NodeArray; + } + interface VariableStatement extends Statement { + declarations: NodeArray; + } + interface ExpressionStatement extends Statement { + expression: Expression; + } + interface IfStatement extends Statement { + expression: Expression; + thenStatement: Statement; + elseStatement?: Statement; + } + interface IterationStatement extends Statement { + statement: Statement; + } + interface DoStatement extends IterationStatement { + expression: Expression; + } + interface WhileStatement extends IterationStatement { + expression: Expression; + } + interface ForStatement extends IterationStatement { + declarations?: NodeArray; + initializer?: Expression; + condition?: Expression; + iterator?: Expression; + } + interface ForInStatement extends IterationStatement { + declarations?: NodeArray; + variable?: Expression; + expression: Expression; + } + interface BreakOrContinueStatement extends Statement { + label?: Identifier; + } + interface ReturnStatement extends Statement { + expression?: Expression; + } + interface WithStatement extends Statement { + expression: Expression; + statement: Statement; + } + interface SwitchStatement extends Statement { + expression: Expression; + clauses: NodeArray; + } + interface CaseOrDefaultClause extends Node { + expression?: Expression; + statements: NodeArray; + } + interface LabeledStatement extends Statement { + label: Identifier; + statement: Statement; + } + interface ThrowStatement extends Statement { + expression: Expression; + } + interface TryStatement extends Statement { + tryBlock: Block; + catchBlock?: CatchBlock; + finallyBlock?: Block; + } + interface CatchBlock extends Block, Declaration { + variable: Identifier; + type?: TypeNode; + } + interface ModuleElement extends Node { + _moduleElementBrand: any; + } + interface ClassDeclaration extends Declaration, ModuleElement { + name: Identifier; + typeParameters?: NodeArray; + heritageClauses?: NodeArray; + members: NodeArray; + } + interface ClassElement extends Declaration { + _classElementBrand: any; + } + interface InterfaceDeclaration extends Declaration, ModuleElement { + name: Identifier; + typeParameters?: NodeArray; + heritageClauses?: NodeArray; + members: NodeArray; + } + interface HeritageClause extends Node { + token: SyntaxKind; + types?: NodeArray; + } + interface TypeAliasDeclaration extends Declaration, ModuleElement { + name: Identifier; + type: TypeNode; + } + interface EnumMember extends Declaration { + name: DeclarationName; + initializer?: Expression; + } + interface EnumDeclaration extends Declaration, ModuleElement { + name: Identifier; + members: NodeArray; + } + interface ModuleDeclaration extends Declaration, ModuleElement { + name: Identifier | LiteralExpression; + body: ModuleBlock | ModuleDeclaration; + } + interface ModuleBlock extends Node, ModuleElement { + statements: NodeArray; + } + interface ImportDeclaration extends Declaration, ModuleElement { + name: Identifier; + entityName?: EntityName; + externalModuleName?: LiteralExpression; + } + interface ExportAssignment extends Statement, ModuleElement { + exportName: Identifier; + } + interface FileReference extends TextRange { + filename: string; + } + interface CommentRange extends TextRange { + hasTrailingNewLine?: boolean; + } + interface SourceFile extends Declaration { + statements: NodeArray; + filename: string; + text: string; + getLineAndCharacterFromPosition(position: number): LineAndCharacter; + getPositionFromLineAndCharacter(line: number, character: number): number; + getLineStarts(): number[]; + amdDependencies: string[]; + amdModuleName: string; + referencedFiles: FileReference[]; + semanticDiagnostics: Diagnostic[]; + parseDiagnostics: Diagnostic[]; + grammarDiagnostics: Diagnostic[]; + getSyntacticDiagnostics(): Diagnostic[]; + hasNoDefaultLib: boolean; + externalModuleIndicator: Node; + nodeCount: number; + identifierCount: number; + symbolCount: number; + isOpen: boolean; + version: string; + languageVersion: ScriptTarget; + identifiers: Map; + } + interface Program { + getSourceFile(filename: string): SourceFile; + getSourceFiles(): SourceFile[]; + getCompilerOptions(): CompilerOptions; + getCompilerHost(): CompilerHost; + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; + getGlobalDiagnostics(): Diagnostic[]; + getTypeChecker(fullTypeCheckMode: boolean): TypeChecker; + getCommonSourceDirectory(): string; + } + interface SourceMapSpan { + emittedLine: number; + emittedColumn: number; + sourceLine: number; + sourceColumn: number; + nameIndex?: number; + sourceIndex: number; + } + interface SourceMapData { + sourceMapFilePath: string; + jsSourceMappingURL: string; + sourceMapFile: string; + sourceMapSourceRoot: string; + sourceMapSources: string[]; + inputSourceFileNames: string[]; + sourceMapNames?: string[]; + sourceMapMappings: string; + sourceMapDecodedMappings: SourceMapSpan[]; + } + enum EmitReturnStatus { + Succeeded = 0, + AllOutputGenerationSkipped = 1, + JSGeneratedWithSemanticErrors = 2, + DeclarationGenerationSkipped = 3, + EmitErrorsEncountered = 4, + CompilerOptionsErrors = 5, + } + interface EmitResult { + emitResultStatus: EmitReturnStatus; + diagnostics: Diagnostic[]; + sourceMaps: SourceMapData[]; + } + interface TypeChecker { + getProgram(): Program; + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; + getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[]; + getGlobalDiagnostics(): Diagnostic[]; + getNodeCount(): number; + getIdentifierCount(): number; + getSymbolCount(): number; + getTypeCount(): number; + checkProgram(): void; + emitFiles(targetSourceFile?: SourceFile): EmitResult; + getParentOfSymbol(symbol: Symbol): Symbol; + getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; + getDeclaredTypeOfSymbol(symbol: Symbol): Type; + getPropertiesOfType(type: Type): Symbol[]; + getPropertyOfType(type: Type, propertyName: string): Symbol; + getSignaturesOfType(type: Type, kind: SignatureKind): Signature[]; + getIndexTypeOfType(type: Type, kind: IndexKind): Type; + getReturnTypeOfSignature(signature: Signature): Type; + getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; + getSymbolInfo(node: Node): Symbol; + getShorthandAssignmentValueSymbol(location: Node): Symbol; + getTypeOfNode(node: Node): Type; + typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; + symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; + getSymbolDisplayBuilder(): SymbolDisplayBuilder; + getFullyQualifiedName(symbol: Symbol): string; + getAugmentedPropertiesOfType(type: Type): Symbol[]; + getRootSymbols(symbol: Symbol): Symbol[]; + getContextualType(node: Node): Type; + getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; + getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature; + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; + isUndefinedSymbol(symbol: Symbol): boolean; + isArgumentsSymbol(symbol: Symbol): boolean; + isEmitBlocked(sourceFile?: SourceFile): boolean; + getEnumMemberValue(node: EnumMember): number; + isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; + getAliasedSymbol(symbol: Symbol): Symbol; + } + interface SymbolDisplayBuilder { + buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void; + buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void; + buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; + } + interface SymbolWriter { + writeKeyword(text: string): void; + writeOperator(text: string): void; + writePunctuation(text: string): void; + writeSpace(text: string): void; + writeStringLiteral(text: string): void; + writeParameter(text: string): void; + writeSymbol(text: string, symbol: Symbol): void; + writeLine(): void; + increaseIndent(): void; + decreaseIndent(): void; + clear(): void; + trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void; + } + const enum TypeFormatFlags { + None = 0, + WriteArrayAsGenericType = 1, + UseTypeOfFunction = 2, + NoTruncation = 4, + WriteArrowStyleSignature = 8, + WriteOwnNameForAnyLike = 16, + WriteTypeArgumentsOfSignature = 32, + InElementType = 64, + } + const enum SymbolFormatFlags { + None = 0, + WriteTypeParametersOrArguments = 1, + UseOnlyExternalAliasing = 2, + } + const enum SymbolAccessibility { + Accessible = 0, + NotAccessible = 1, + CannotBeNamed = 2, + } + interface SymbolVisibilityResult { + accessibility: SymbolAccessibility; + aliasesToMakeVisible?: ImportDeclaration[]; + errorSymbolName?: string; + errorNode?: Node; + } + interface SymbolAccessiblityResult extends SymbolVisibilityResult { + errorModuleName?: string; + } + interface EmitResolver { + getProgram(): Program; + getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string; + getExpressionNamePrefix(node: Identifier): string; + getExportAssignmentName(node: SourceFile): string; + isReferencedImportDeclaration(node: ImportDeclaration): boolean; + isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; + getNodeCheckFlags(node: Node): NodeCheckFlags; + getEnumMemberValue(node: EnumMember): number; + hasSemanticErrors(): boolean; + isDeclarationVisible(node: Declaration): boolean; + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; + writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; + writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; + isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult; + isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult; + getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number; + isEmitBlocked(sourceFile?: SourceFile): boolean; + } + const enum SymbolFlags { + FunctionScopedVariable = 1, + BlockScopedVariable = 2, + Property = 4, + EnumMember = 8, + Function = 16, + Class = 32, + Interface = 64, + ConstEnum = 128, + RegularEnum = 256, + ValueModule = 512, + NamespaceModule = 1024, + TypeLiteral = 2048, + ObjectLiteral = 4096, + Method = 8192, + Constructor = 16384, + GetAccessor = 32768, + SetAccessor = 65536, + CallSignature = 131072, + ConstructSignature = 262144, + IndexSignature = 524288, + TypeParameter = 1048576, + TypeAlias = 2097152, + ExportValue = 4194304, + ExportType = 8388608, + ExportNamespace = 16777216, + Import = 33554432, + Instantiated = 67108864, + Merged = 134217728, + Transient = 268435456, + Prototype = 536870912, + UnionProperty = 1073741824, + Enum = 384, + Variable = 3, + Value = 107455, + Type = 3152352, + Namespace = 1536, + Module = 1536, + Accessor = 98304, + Signature = 917504, + FunctionScopedVariableExcludes = 107454, + BlockScopedVariableExcludes = 107455, + ParameterExcludes = 107455, + PropertyExcludes = 107455, + EnumMemberExcludes = 107455, + FunctionExcludes = 106927, + ClassExcludes = 3258879, + InterfaceExcludes = 3152288, + RegularEnumExcludes = 3258623, + ConstEnumExcludes = 3259263, + ValueModuleExcludes = 106639, + NamespaceModuleExcludes = 0, + MethodExcludes = 99263, + GetAccessorExcludes = 41919, + SetAccessorExcludes = 74687, + TypeParameterExcludes = 2103776, + TypeAliasExcludes = 3152352, + ImportExcludes = 33554432, + ModuleMember = 35653619, + ExportHasLocal = 944, + HasLocals = 1041936, + HasExports = 1952, + HasMembers = 6240, + IsContainer = 1048560, + PropertyOrAccessor = 98308, + Export = 29360128, + } + interface Symbol { + flags: SymbolFlags; + name: string; + id?: number; + mergeId?: number; + declarations?: Declaration[]; + parent?: Symbol; + members?: SymbolTable; + exports?: SymbolTable; + exportSymbol?: Symbol; + valueDeclaration?: Declaration; + constEnumOnlyModule?: boolean; + } + interface SymbolLinks { + target?: Symbol; + type?: Type; + declaredType?: Type; + mapper?: TypeMapper; + referenced?: boolean; + exportAssignSymbol?: Symbol; + unionType?: UnionType; + } + interface TransientSymbol extends Symbol, SymbolLinks { + } + interface SymbolTable { + [index: string]: Symbol; + } + const enum NodeCheckFlags { + TypeChecked = 1, + LexicalThis = 2, + CaptureThis = 4, + EmitExtends = 8, + SuperInstance = 16, + SuperStatic = 32, + ContextChecked = 64, + EnumValuesComputed = 128, + } + interface NodeLinks { + resolvedType?: Type; + resolvedSignature?: Signature; + resolvedSymbol?: Symbol; + flags?: NodeCheckFlags; + enumMemberValue?: number; + isIllegalTypeReferenceInConstraint?: boolean; + isVisible?: boolean; + localModuleName?: string; + assignmentChecks?: Map; + } + const enum TypeFlags { + Any = 1, + String = 2, + Number = 4, + Boolean = 8, + Void = 16, + Undefined = 32, + Null = 64, + Enum = 128, + StringLiteral = 256, + TypeParameter = 512, + Class = 1024, + Interface = 2048, + Reference = 4096, + Tuple = 8192, + Union = 16384, + Anonymous = 32768, + FromSignature = 65536, + Intrinsic = 127, + StringLike = 258, + NumberLike = 132, + ObjectType = 48128, + Structured = 65025, + } + interface Type { + flags: TypeFlags; + id: number; + symbol?: Symbol; + } + interface IntrinsicType extends Type { + intrinsicName: string; + } + interface StringLiteralType extends Type { + text: string; + } + interface ObjectType extends Type { + } + interface InterfaceType extends ObjectType { + typeParameters: TypeParameter[]; + baseTypes: ObjectType[]; + declaredProperties: Symbol[]; + declaredCallSignatures: Signature[]; + declaredConstructSignatures: Signature[]; + declaredStringIndexType: Type; + declaredNumberIndexType: Type; + } + interface TypeReference extends ObjectType { + target: GenericType; + typeArguments: Type[]; + } + interface GenericType extends InterfaceType, TypeReference { + instantiations: Map; + openReferenceTargets: GenericType[]; + openReferenceChecks: Map; + } + interface TupleType extends ObjectType { + elementTypes: Type[]; + baseArrayType: TypeReference; + } + interface UnionType extends Type { + types: Type[]; + resolvedProperties: SymbolTable; + } + interface ResolvedType extends ObjectType, UnionType { + members: SymbolTable; + properties: Symbol[]; + callSignatures: Signature[]; + constructSignatures: Signature[]; + stringIndexType: Type; + numberIndexType: Type; + } + interface TypeParameter extends Type { + constraint: Type; + target?: TypeParameter; + mapper?: TypeMapper; + } + const enum SignatureKind { + Call = 0, + Construct = 1, + } + interface Signature { + declaration: SignatureDeclaration; + typeParameters: TypeParameter[]; + parameters: Symbol[]; + resolvedReturnType: Type; + minArgumentCount: number; + hasRestParameter: boolean; + hasStringLiterals: boolean; + target?: Signature; + mapper?: TypeMapper; + unionSignatures?: Signature[]; + erasedSignatureCache?: Signature; + isolatedSignatureType?: ObjectType; + } + const enum IndexKind { + String = 0, + Number = 1, + } + interface TypeMapper { + (t: Type): Type; + } + interface TypeInferences { + primary: Type[]; + secondary: Type[]; + } + interface InferenceContext { + typeParameters: TypeParameter[]; + inferUnionTypes: boolean; + inferences: TypeInferences[]; + inferredTypes: Type[]; + failedTypeParameterIndex?: number; + } + interface DiagnosticMessage { + key: string; + category: DiagnosticCategory; + code: number; + isEarly?: boolean; + } + interface DiagnosticMessageChain { + messageText: string; + category: DiagnosticCategory; + code: number; + next?: DiagnosticMessageChain; + } + interface Diagnostic { + file: SourceFile; + start: number; + length: number; + messageText: string; + category: DiagnosticCategory; + code: number; + /** + * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit + */ + isEarly?: boolean; + /** + * Parse error - error produced by parser when it scanner returns a token + * that parser does not understand in its current state + * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) + */ + isParseError?: boolean; + } + enum DiagnosticCategory { + Warning = 0, + Error = 1, + Message = 2, + } + interface CompilerOptions { + charset?: string; + codepage?: number; + declaration?: boolean; + diagnostics?: boolean; + emitBOM?: boolean; + help?: boolean; + locale?: string; + mapRoot?: string; + module?: ModuleKind; + noEmitOnError?: boolean; + noErrorTruncation?: boolean; + noImplicitAny?: boolean; + noLib?: boolean; + noLibCheck?: boolean; + noResolve?: boolean; + out?: string; + outDir?: string; + removeComments?: boolean; + sourceMap?: boolean; + sourceRoot?: string; + target?: ScriptTarget; + version?: boolean; + watch?: boolean; + preserveConstEnums?: boolean; + [option: string]: string | number | boolean; + } + const enum ModuleKind { + None = 0, + CommonJS = 1, + AMD = 2, + } + interface LineAndCharacter { + line: number; + character: number; + } + const enum ScriptTarget { + ES3 = 0, + ES5 = 1, + ES6 = 2, + Latest = 2, + } + interface ParsedCommandLine { + options: CompilerOptions; + filenames: string[]; + errors: Diagnostic[]; + } + interface CommandLineOption { + name: string; + type: string | Map; + shortName?: string; + description?: DiagnosticMessage; + paramName?: DiagnosticMessage; + error?: DiagnosticMessage; + } + const enum CharacterCodes { + nullCharacter = 0, + maxAsciiCharacter = 127, + lineFeed = 10, + carriageReturn = 13, + lineSeparator = 8232, + paragraphSeparator = 8233, + nextLine = 133, + space = 32, + nonBreakingSpace = 160, + enQuad = 8192, + emQuad = 8193, + enSpace = 8194, + emSpace = 8195, + threePerEmSpace = 8196, + fourPerEmSpace = 8197, + sixPerEmSpace = 8198, + figureSpace = 8199, + punctuationSpace = 8200, + thinSpace = 8201, + hairSpace = 8202, + zeroWidthSpace = 8203, + narrowNoBreakSpace = 8239, + ideographicSpace = 12288, + mathematicalSpace = 8287, + ogham = 5760, + _ = 95, + $ = 36, + _0 = 48, + _1 = 49, + _2 = 50, + _3 = 51, + _4 = 52, + _5 = 53, + _6 = 54, + _7 = 55, + _8 = 56, + _9 = 57, + a = 97, + b = 98, + c = 99, + d = 100, + e = 101, + f = 102, + g = 103, + h = 104, + i = 105, + j = 106, + k = 107, + l = 108, + m = 109, + n = 110, + o = 111, + p = 112, + q = 113, + r = 114, + s = 115, + t = 116, + u = 117, + v = 118, + w = 119, + x = 120, + y = 121, + z = 122, + A = 65, + B = 66, + C = 67, + D = 68, + E = 69, + F = 70, + G = 71, + H = 72, + I = 73, + J = 74, + K = 75, + L = 76, + M = 77, + N = 78, + O = 79, + P = 80, + Q = 81, + R = 82, + S = 83, + T = 84, + U = 85, + V = 86, + W = 87, + X = 88, + Y = 89, + Z = 90, + ampersand = 38, + asterisk = 42, + at = 64, + backslash = 92, + backtick = 96, + bar = 124, + caret = 94, + closeBrace = 125, + closeBracket = 93, + closeParen = 41, + colon = 58, + comma = 44, + dot = 46, + doubleQuote = 34, + equals = 61, + exclamation = 33, + greaterThan = 62, + lessThan = 60, + minus = 45, + openBrace = 123, + openBracket = 91, + openParen = 40, + percent = 37, + plus = 43, + question = 63, + semicolon = 59, + singleQuote = 39, + slash = 47, + tilde = 126, + backspace = 8, + formFeed = 12, + byteOrderMark = 65279, + tab = 9, + verticalTab = 11, + } + interface CancellationToken { + isCancellationRequested(): boolean; + } + interface CompilerHost { + getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; + getDefaultLibFilename(): string; + getCancellationToken?(): CancellationToken; + writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; + getCurrentDirectory(): string; + getCanonicalFileName(fileName: string): string; + useCaseSensitiveFileNames(): boolean; + getNewLine(): string; + } +} +declare module ts { + interface ErrorCallback { + (message: DiagnosticMessage): void; + } + interface CommentCallback { + (pos: number, end: number): void; + } + interface Scanner { + getStartPos(): number; + getToken(): SyntaxKind; + getTextPos(): number; + getTokenPos(): number; + getTokenText(): string; + getTokenValue(): string; + hasPrecedingLineBreak(): boolean; + isIdentifier(): boolean; + isReservedWord(): boolean; + reScanGreaterToken(): SyntaxKind; + reScanSlashToken(): SyntaxKind; + reScanTemplateToken(): SyntaxKind; + scan(): SyntaxKind; + setText(text: string): void; + setTextPos(textPos: number): void; + tryScan(callback: () => T): T; + } + function tokenToString(t: SyntaxKind): string; + function computeLineStarts(text: string): number[]; + function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number; + function getLineAndCharacterOfPosition(lineStarts: number[], position: number): { + line: number; + character: number; + }; + function positionToLineAndCharacter(text: string, pos: number): { + line: number; + character: number; + }; + function isWhiteSpace(ch: number): boolean; + function isLineBreak(ch: number): boolean; + function isOctalDigit(ch: number): boolean; + function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number; + function getLeadingCommentRanges(text: string, pos: number): CommentRange[]; + function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; + function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; + function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; +} +declare module ts { + interface ReferencePathMatchResult { + fileReference?: FileReference; + diagnostic?: DiagnosticMessage; + isNoDefaultLib?: boolean; + } + function getNodeConstructor(kind: SyntaxKind): new () => Node; + function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; + function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; + function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program; +} +declare module ts { + function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker; +} +declare module ts { + interface Node { + getSourceFile(): SourceFile; + getChildCount(sourceFile?: SourceFile): number; + getChildAt(index: number, sourceFile?: SourceFile): Node; + getChildren(sourceFile?: SourceFile): Node[]; + getStart(sourceFile?: SourceFile): number; + getFullStart(): number; + getEnd(): number; + getWidth(sourceFile?: SourceFile): number; + getFullWidth(): number; + getLeadingTriviaWidth(sourceFile?: SourceFile): number; + getFullText(sourceFile?: SourceFile): string; + getText(sourceFile?: SourceFile): string; + getFirstToken(sourceFile?: SourceFile): Node; + getLastToken(sourceFile?: SourceFile): Node; + } + interface Symbol { + getFlags(): SymbolFlags; + getName(): string; + getDeclarations(): Declaration[]; + getDocumentationComment(): SymbolDisplayPart[]; + } + interface Type { + getFlags(): TypeFlags; + getSymbol(): Symbol; + getProperties(): Symbol[]; + getProperty(propertyName: string): Symbol; + getApparentProperties(): Symbol[]; + getCallSignatures(): Signature[]; + getConstructSignatures(): Signature[]; + getStringIndexType(): Type; + getNumberIndexType(): Type; + } + interface Signature { + getDeclaration(): SignatureDeclaration; + getTypeParameters(): Type[]; + getParameters(): Symbol[]; + getReturnType(): Type; + getDocumentationComment(): SymbolDisplayPart[]; + } + interface SourceFile { + getScriptSnapshot(): IScriptSnapshot; + getNamedDeclarations(): Declaration[]; + update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; + } + /** + * Represents an immutable snapshot of a script at a specified time.Once acquired, the + * snapshot is observably immutable. i.e. the same calls with the same parameters will return + * the same values. + */ + interface IScriptSnapshot { + /** Gets a portion of the script snapshot specified by [start, end). */ + getText(start: number, end: number): string; + /** Gets the length of this script snapshot. */ + getLength(): number; + /** + * This call returns the array containing the start position of every line. + * i.e."[0, 10, 55]". TODO: consider making this optional. The language service could + * always determine this (albeit in a more expensive manner). + */ + getLineStartPositions(): number[]; + /** + * Gets the TextChangeRange that describe how the text changed between this text and + * an older version. This information is used by the incremental parser to determine + * what sections of the script need to be re-parsed. 'undefined' can be returned if the + * change range cannot be determined. However, in that case, incremental parsing will + * not happen and the entire document will be re - parsed. + */ + getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange; + } + module ScriptSnapshot { + function fromString(text: string): IScriptSnapshot; + } + interface PreProcessedFileInfo { + referencedFiles: FileReference[]; + importedFiles: FileReference[]; + isLibFile: boolean; + } + interface Logger { + log(s: string): void; + } + interface LanguageServiceHost extends Logger { + getCompilationSettings(): CompilerOptions; + getScriptFileNames(): string[]; + getScriptVersion(fileName: string): string; + getScriptIsOpen(fileName: string): boolean; + getScriptSnapshot(fileName: string): IScriptSnapshot; + getLocalizedDiagnosticMessages(): any; + getCancellationToken(): CancellationToken; + getCurrentDirectory(): string; + getDefaultLibFilename(): string; + } + interface LanguageService { + cleanupSemanticCache(): void; + getSyntacticDiagnostics(fileName: string): Diagnostic[]; + getSemanticDiagnostics(fileName: string): Diagnostic[]; + getCompilerOptionsDiagnostics(): Diagnostic[]; + getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; + getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; + getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; + getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; + getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan; + getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan; + getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems; + getRenameInfo(fileName: string, position: number): RenameInfo; + findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[]; + getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[]; + getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[]; + getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[]; + getNavigateToItems(searchValue: string): NavigateToItem[]; + getNavigationBarItems(fileName: string): NavigationBarItem[]; + getOutliningSpans(fileName: string): OutliningSpan[]; + getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[]; + getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[]; + getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number; + getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[]; + getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[]; + getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[]; + getEmitOutput(fileName: string): EmitOutput; + getSourceFile(filename: string): SourceFile; + dispose(): void; + } + class TextSpan { + private _start; + private _length; + /** + * Creates a TextSpan instance beginning with the position Start and having the Length + * specified with length. + */ + constructor(start: number, length: number); + toJSON(key: any): any; + start(): number; + length(): number; + end(): number; + isEmpty(): boolean; + /** + * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less + * than End, otherwise false. + * @param position The position to check. + */ + containsPosition(position: number): boolean; + /** + * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false. + * @param span The span to check. + */ + containsTextSpan(span: TextSpan): boolean; + /** + * Determines whether the given span overlaps this span. Two spans are considered to overlap + * if they have positions in common and neither is empty. Empty spans do not overlap with any + * other span. Returns true if the spans overlap, false otherwise. + * @param span The span to check. + */ + overlapsWith(span: TextSpan): boolean; + /** + * Returns the overlap with the given span, or undefined if there is no overlap. + * @param span The span to check. + */ + overlap(span: TextSpan): TextSpan; + /** + * Determines whether span intersects this span. Two spans are considered to + * intersect if they have positions in common or the end of one span + * coincides with the start of the other span. Returns true if the spans intersect, false otherwise. + * @param The span to check. + */ + intersectsWithTextSpan(span: TextSpan): boolean; + intersectsWith(start: number, length: number): boolean; + /** + * Determines whether the given position intersects this span. + * A position is considered to intersect if it is between the start and + * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise. + * @param position The position to check. + */ + intersectsWithPosition(position: number): boolean; + /** + * Returns the intersection with the given span, or undefined if there is no intersection. + * @param span The span to check. + */ + intersection(span: TextSpan): TextSpan; + /** + * Creates a new TextSpan from the given start and end positions + * as opposed to a position and length. + */ + static fromBounds(start: number, end: number): TextSpan; + } + class TextChangeRange { + static unchanged: TextChangeRange; + private _span; + private _newLength; + /** + * Initializes a new instance of TextChangeRange. + */ + constructor(span: TextSpan, newLength: number); + /** + * The span of text before the edit which is being changed + */ + span(): TextSpan; + /** + * Width of the span after the edit. A 0 here would represent a delete + */ + newLength(): number; + newSpan(): TextSpan; + isUnchanged(): boolean; + /** + * Called to merge all the changes that occurred across several versions of a script snapshot + * into a single change. i.e. if a user keeps making successive edits to a script we will + * have a text change from V1 to V2, V2 to V3, ..., Vn. + * + * This function will then merge those changes into a single change range valid between V1 and + * Vn. + */ + static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; + } + interface ClassifiedSpan { + textSpan: TextSpan; + classificationType: string; + } + interface NavigationBarItem { + text: string; + kind: string; + kindModifiers: string; + spans: TextSpan[]; + childItems: NavigationBarItem[]; + indent: number; + bolded: boolean; + grayed: boolean; + } + interface TodoCommentDescriptor { + text: string; + priority: number; + } + interface TodoComment { + descriptor: TodoCommentDescriptor; + message: string; + position: number; + } + class TextChange { + span: TextSpan; + newText: string; + } + interface RenameLocation { + textSpan: TextSpan; + fileName: string; + } + interface ReferenceEntry { + textSpan: TextSpan; + fileName: string; + isWriteAccess: boolean; + } + interface NavigateToItem { + name: string; + kind: string; + kindModifiers: string; + matchKind: string; + fileName: string; + textSpan: TextSpan; + containerName: string; + containerKind: string; + } + interface EditorOptions { + IndentSize: number; + TabSize: number; + NewLineCharacter: string; + ConvertTabsToSpaces: boolean; + } + interface FormatCodeOptions extends EditorOptions { + InsertSpaceAfterCommaDelimiter: boolean; + InsertSpaceAfterSemicolonInForStatements: boolean; + InsertSpaceBeforeAndAfterBinaryOperators: boolean; + InsertSpaceAfterKeywordsInControlFlowStatements: boolean; + InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean; + InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean; + PlaceOpenBraceOnNewLineForFunctions: boolean; + PlaceOpenBraceOnNewLineForControlBlocks: boolean; + } + interface DefinitionInfo { + fileName: string; + textSpan: TextSpan; + kind: string; + name: string; + containerKind: string; + containerName: string; + } + enum SymbolDisplayPartKind { + aliasName = 0, + className = 1, + enumName = 2, + fieldName = 3, + interfaceName = 4, + keyword = 5, + lineBreak = 6, + numericLiteral = 7, + stringLiteral = 8, + localName = 9, + methodName = 10, + moduleName = 11, + operator = 12, + parameterName = 13, + propertyName = 14, + punctuation = 15, + space = 16, + text = 17, + typeParameterName = 18, + enumMemberName = 19, + functionName = 20, + regularExpressionLiteral = 21, + } + interface SymbolDisplayPart { + text: string; + kind: string; + } + interface QuickInfo { + kind: string; + kindModifiers: string; + textSpan: TextSpan; + displayParts: SymbolDisplayPart[]; + documentation: SymbolDisplayPart[]; + } + interface RenameInfo { + canRename: boolean; + localizedErrorMessage: string; + displayName: string; + fullDisplayName: string; + kind: string; + kindModifiers: string; + triggerSpan: TextSpan; + } + interface SignatureHelpParameter { + name: string; + documentation: SymbolDisplayPart[]; + displayParts: SymbolDisplayPart[]; + isOptional: boolean; + } + /** + * Represents a single signature to show in signature help. + * The id is used for subsequent calls into the language service to ask questions about the + * signature help item in the context of any documents that have been updated. i.e. after + * an edit has happened, while signature help is still active, the host can ask important + * questions like 'what parameter is the user currently contained within?'. + */ + interface SignatureHelpItem { + isVariadic: boolean; + prefixDisplayParts: SymbolDisplayPart[]; + suffixDisplayParts: SymbolDisplayPart[]; + separatorDisplayParts: SymbolDisplayPart[]; + parameters: SignatureHelpParameter[]; + documentation: SymbolDisplayPart[]; + } + /** + * Represents a set of signature help items, and the preferred item that should be selected. + */ + interface SignatureHelpItems { + items: SignatureHelpItem[]; + applicableSpan: TextSpan; + selectedItemIndex: number; + argumentIndex: number; + argumentCount: number; + } + interface CompletionInfo { + isMemberCompletion: boolean; + entries: CompletionEntry[]; + } + interface CompletionEntry { + name: string; + kind: string; + kindModifiers: string; + } + interface CompletionEntryDetails { + name: string; + kind: string; + kindModifiers: string; + displayParts: SymbolDisplayPart[]; + documentation: SymbolDisplayPart[]; + } + interface OutliningSpan { + /** The span of the document to actually collapse. */ + textSpan: TextSpan; + /** The span of the document to display when the user hovers over the collapsed span. */ + hintSpan: TextSpan; + /** The text to display in the editor for the collapsed region. */ + bannerText: string; + /** + * Whether or not this region should be automatically collapsed when + * the 'Collapse to Definitions' command is invoked. + */ + autoCollapse: boolean; + } + interface EmitOutput { + outputFiles: OutputFile[]; + emitOutputStatus: EmitReturnStatus; + } + const enum OutputFileType { + JavaScript = 0, + SourceMap = 1, + Declaration = 2, + } + interface OutputFile { + name: string; + writeByteOrderMark: boolean; + text: string; + } + const enum EndOfLineState { + Start = 0, + InMultiLineCommentTrivia = 1, + InSingleQuoteStringLiteral = 2, + InDoubleQuoteStringLiteral = 3, + } + enum TokenClass { + Punctuation = 0, + Keyword = 1, + Operator = 2, + Comment = 3, + Whitespace = 4, + Identifier = 5, + NumberLiteral = 6, + StringLiteral = 7, + RegExpLiteral = 8, + } + interface ClassificationResult { + finalLexState: EndOfLineState; + entries: ClassificationInfo[]; + } + interface ClassificationInfo { + length: number; + classification: TokenClass; + } + interface Classifier { + getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult; + } + interface DocumentRegistry { + acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile; + updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; + releaseDocument(filename: string, compilationSettings: CompilerOptions): void; + } + class ScriptElementKind { + static unknown: string; + static keyword: string; + static scriptElement: string; + static moduleElement: string; + static classElement: string; + static interfaceElement: string; + static typeElement: string; + static enumElement: string; + static variableElement: string; + static localVariableElement: string; + static functionElement: string; + static localFunctionElement: string; + static memberFunctionElement: string; + static memberGetAccessorElement: string; + static memberSetAccessorElement: string; + static memberVariableElement: string; + static constructorImplementationElement: string; + static callSignatureElement: string; + static indexSignatureElement: string; + static constructSignatureElement: string; + static parameterElement: string; + static typeParameterElement: string; + static primitiveType: string; + static label: string; + static alias: string; + static constElement: string; + static letElement: string; + } + class ScriptElementKindModifier { + static none: string; + static publicMemberModifier: string; + static privateMemberModifier: string; + static protectedMemberModifier: string; + static exportedModifier: string; + static ambientModifier: string; + static staticModifier: string; + } + class ClassificationTypeNames { + static comment: string; + static identifier: string; + static keyword: string; + static numericLiteral: string; + static operator: string; + static stringLiteral: string; + static whiteSpace: string; + static text: string; + static punctuation: string; + static className: string; + static enumName: string; + static interfaceName: string; + static moduleName: string; + static typeParameterName: string; + } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; + interface DisplayPartsSymbolWriter extends SymbolWriter { + displayParts(): SymbolDisplayPart[]; + } + function getDefaultCompilerOptions(): CompilerOptions; + class OperationCanceledException { + } + class CancellationTokenObject { + private cancellationToken; + static None: CancellationTokenObject; + constructor(cancellationToken: CancellationToken); + isCancellationRequested(): boolean; + throwIfCancellationRequested(): void; + } + function createDocumentRegistry(): DocumentRegistry; + function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; + function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService; + function createClassifier(host: Logger): Classifier; +} + + +//// [APISample_standalone_compile.js] +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", 2 /* Latest */, "0.0"); +var program = ts.createProgram(["file1.ts"], {}, undefined); diff --git a/tests/baselines/reference/APISample_standalone_compile.types b/tests/baselines/reference/APISample_standalone_compile.types new file mode 100644 index 0000000000000..ebde76e4aa4d3 --- /dev/null +++ b/tests/baselines/reference/APISample_standalone_compile.types @@ -0,0 +1,5641 @@ +=== tests/cases/compiler/APISample_standalone_compile.ts === + +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0"); +>sourceFile : ts.SourceFile +>ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0") : ts.SourceFile +>ts.createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile +>ts : typeof ts +>createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile +>ts.ScriptTarget.Latest : ts.ScriptTarget +>ts.ScriptTarget : typeof ts.ScriptTarget +>ts : typeof ts +>ScriptTarget : typeof ts.ScriptTarget +>Latest : ts.ScriptTarget + +var program = ts.createProgram(["file1.ts"], {}, undefined); +>program : ts.Program +>ts.createProgram(["file1.ts"], {}, undefined) : ts.Program +>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program +>ts : typeof ts +>createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program +>["file1.ts"] : string[] +>{} : { [x: string]: undefined; } +>undefined : undefined + +=== typescriptServices.d.ts === +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +declare module ts { +>ts : typeof ts + + interface Map { +>Map : Map +>T : T + + [index: string]: T; +>index : string +>T : T + } + interface TextRange { +>TextRange : TextRange + + pos: number; +>pos : number + + end: number; +>end : number + } + const enum SyntaxKind { +>SyntaxKind : SyntaxKind + + Unknown = 0, +>Unknown : SyntaxKind + + EndOfFileToken = 1, +>EndOfFileToken : SyntaxKind + + SingleLineCommentTrivia = 2, +>SingleLineCommentTrivia : SyntaxKind + + MultiLineCommentTrivia = 3, +>MultiLineCommentTrivia : SyntaxKind + + NewLineTrivia = 4, +>NewLineTrivia : SyntaxKind + + WhitespaceTrivia = 5, +>WhitespaceTrivia : SyntaxKind + + NumericLiteral = 6, +>NumericLiteral : SyntaxKind + + StringLiteral = 7, +>StringLiteral : SyntaxKind + + RegularExpressionLiteral = 8, +>RegularExpressionLiteral : SyntaxKind + + NoSubstitutionTemplateLiteral = 9, +>NoSubstitutionTemplateLiteral : SyntaxKind + + TemplateHead = 10, +>TemplateHead : SyntaxKind + + TemplateMiddle = 11, +>TemplateMiddle : SyntaxKind + + TemplateTail = 12, +>TemplateTail : SyntaxKind + + OpenBraceToken = 13, +>OpenBraceToken : SyntaxKind + + CloseBraceToken = 14, +>CloseBraceToken : SyntaxKind + + OpenParenToken = 15, +>OpenParenToken : SyntaxKind + + CloseParenToken = 16, +>CloseParenToken : SyntaxKind + + OpenBracketToken = 17, +>OpenBracketToken : SyntaxKind + + CloseBracketToken = 18, +>CloseBracketToken : SyntaxKind + + DotToken = 19, +>DotToken : SyntaxKind + + DotDotDotToken = 20, +>DotDotDotToken : SyntaxKind + + SemicolonToken = 21, +>SemicolonToken : SyntaxKind + + CommaToken = 22, +>CommaToken : SyntaxKind + + LessThanToken = 23, +>LessThanToken : SyntaxKind + + GreaterThanToken = 24, +>GreaterThanToken : SyntaxKind + + LessThanEqualsToken = 25, +>LessThanEqualsToken : SyntaxKind + + GreaterThanEqualsToken = 26, +>GreaterThanEqualsToken : SyntaxKind + + EqualsEqualsToken = 27, +>EqualsEqualsToken : SyntaxKind + + ExclamationEqualsToken = 28, +>ExclamationEqualsToken : SyntaxKind + + EqualsEqualsEqualsToken = 29, +>EqualsEqualsEqualsToken : SyntaxKind + + ExclamationEqualsEqualsToken = 30, +>ExclamationEqualsEqualsToken : SyntaxKind + + EqualsGreaterThanToken = 31, +>EqualsGreaterThanToken : SyntaxKind + + PlusToken = 32, +>PlusToken : SyntaxKind + + MinusToken = 33, +>MinusToken : SyntaxKind + + AsteriskToken = 34, +>AsteriskToken : SyntaxKind + + SlashToken = 35, +>SlashToken : SyntaxKind + + PercentToken = 36, +>PercentToken : SyntaxKind + + PlusPlusToken = 37, +>PlusPlusToken : SyntaxKind + + MinusMinusToken = 38, +>MinusMinusToken : SyntaxKind + + LessThanLessThanToken = 39, +>LessThanLessThanToken : SyntaxKind + + GreaterThanGreaterThanToken = 40, +>GreaterThanGreaterThanToken : SyntaxKind + + GreaterThanGreaterThanGreaterThanToken = 41, +>GreaterThanGreaterThanGreaterThanToken : SyntaxKind + + AmpersandToken = 42, +>AmpersandToken : SyntaxKind + + BarToken = 43, +>BarToken : SyntaxKind + + CaretToken = 44, +>CaretToken : SyntaxKind + + ExclamationToken = 45, +>ExclamationToken : SyntaxKind + + TildeToken = 46, +>TildeToken : SyntaxKind + + AmpersandAmpersandToken = 47, +>AmpersandAmpersandToken : SyntaxKind + + BarBarToken = 48, +>BarBarToken : SyntaxKind + + QuestionToken = 49, +>QuestionToken : SyntaxKind + + ColonToken = 50, +>ColonToken : SyntaxKind + + EqualsToken = 51, +>EqualsToken : SyntaxKind + + PlusEqualsToken = 52, +>PlusEqualsToken : SyntaxKind + + MinusEqualsToken = 53, +>MinusEqualsToken : SyntaxKind + + AsteriskEqualsToken = 54, +>AsteriskEqualsToken : SyntaxKind + + SlashEqualsToken = 55, +>SlashEqualsToken : SyntaxKind + + PercentEqualsToken = 56, +>PercentEqualsToken : SyntaxKind + + LessThanLessThanEqualsToken = 57, +>LessThanLessThanEqualsToken : SyntaxKind + + GreaterThanGreaterThanEqualsToken = 58, +>GreaterThanGreaterThanEqualsToken : SyntaxKind + + GreaterThanGreaterThanGreaterThanEqualsToken = 59, +>GreaterThanGreaterThanGreaterThanEqualsToken : SyntaxKind + + AmpersandEqualsToken = 60, +>AmpersandEqualsToken : SyntaxKind + + BarEqualsToken = 61, +>BarEqualsToken : SyntaxKind + + CaretEqualsToken = 62, +>CaretEqualsToken : SyntaxKind + + Identifier = 63, +>Identifier : SyntaxKind + + BreakKeyword = 64, +>BreakKeyword : SyntaxKind + + CaseKeyword = 65, +>CaseKeyword : SyntaxKind + + CatchKeyword = 66, +>CatchKeyword : SyntaxKind + + ClassKeyword = 67, +>ClassKeyword : SyntaxKind + + ConstKeyword = 68, +>ConstKeyword : SyntaxKind + + ContinueKeyword = 69, +>ContinueKeyword : SyntaxKind + + DebuggerKeyword = 70, +>DebuggerKeyword : SyntaxKind + + DefaultKeyword = 71, +>DefaultKeyword : SyntaxKind + + DeleteKeyword = 72, +>DeleteKeyword : SyntaxKind + + DoKeyword = 73, +>DoKeyword : SyntaxKind + + ElseKeyword = 74, +>ElseKeyword : SyntaxKind + + EnumKeyword = 75, +>EnumKeyword : SyntaxKind + + ExportKeyword = 76, +>ExportKeyword : SyntaxKind + + ExtendsKeyword = 77, +>ExtendsKeyword : SyntaxKind + + FalseKeyword = 78, +>FalseKeyword : SyntaxKind + + FinallyKeyword = 79, +>FinallyKeyword : SyntaxKind + + ForKeyword = 80, +>ForKeyword : SyntaxKind + + FunctionKeyword = 81, +>FunctionKeyword : SyntaxKind + + IfKeyword = 82, +>IfKeyword : SyntaxKind + + ImportKeyword = 83, +>ImportKeyword : SyntaxKind + + InKeyword = 84, +>InKeyword : SyntaxKind + + InstanceOfKeyword = 85, +>InstanceOfKeyword : SyntaxKind + + NewKeyword = 86, +>NewKeyword : SyntaxKind + + NullKeyword = 87, +>NullKeyword : SyntaxKind + + ReturnKeyword = 88, +>ReturnKeyword : SyntaxKind + + SuperKeyword = 89, +>SuperKeyword : SyntaxKind + + SwitchKeyword = 90, +>SwitchKeyword : SyntaxKind + + ThisKeyword = 91, +>ThisKeyword : SyntaxKind + + ThrowKeyword = 92, +>ThrowKeyword : SyntaxKind + + TrueKeyword = 93, +>TrueKeyword : SyntaxKind + + TryKeyword = 94, +>TryKeyword : SyntaxKind + + TypeOfKeyword = 95, +>TypeOfKeyword : SyntaxKind + + VarKeyword = 96, +>VarKeyword : SyntaxKind + + VoidKeyword = 97, +>VoidKeyword : SyntaxKind + + WhileKeyword = 98, +>WhileKeyword : SyntaxKind + + WithKeyword = 99, +>WithKeyword : SyntaxKind + + ImplementsKeyword = 100, +>ImplementsKeyword : SyntaxKind + + InterfaceKeyword = 101, +>InterfaceKeyword : SyntaxKind + + LetKeyword = 102, +>LetKeyword : SyntaxKind + + PackageKeyword = 103, +>PackageKeyword : SyntaxKind + + PrivateKeyword = 104, +>PrivateKeyword : SyntaxKind + + ProtectedKeyword = 105, +>ProtectedKeyword : SyntaxKind + + PublicKeyword = 106, +>PublicKeyword : SyntaxKind + + StaticKeyword = 107, +>StaticKeyword : SyntaxKind + + YieldKeyword = 108, +>YieldKeyword : SyntaxKind + + AnyKeyword = 109, +>AnyKeyword : SyntaxKind + + BooleanKeyword = 110, +>BooleanKeyword : SyntaxKind + + ConstructorKeyword = 111, +>ConstructorKeyword : SyntaxKind + + DeclareKeyword = 112, +>DeclareKeyword : SyntaxKind + + GetKeyword = 113, +>GetKeyword : SyntaxKind + + ModuleKeyword = 114, +>ModuleKeyword : SyntaxKind + + RequireKeyword = 115, +>RequireKeyword : SyntaxKind + + NumberKeyword = 116, +>NumberKeyword : SyntaxKind + + SetKeyword = 117, +>SetKeyword : SyntaxKind + + StringKeyword = 118, +>StringKeyword : SyntaxKind + + TypeKeyword = 119, +>TypeKeyword : SyntaxKind + + Missing = 120, +>Missing : SyntaxKind + + QualifiedName = 121, +>QualifiedName : SyntaxKind + + ComputedPropertyName = 122, +>ComputedPropertyName : SyntaxKind + + TypeParameter = 123, +>TypeParameter : SyntaxKind + + Parameter = 124, +>Parameter : SyntaxKind + + Property = 125, +>Property : SyntaxKind + + Method = 126, +>Method : SyntaxKind + + Constructor = 127, +>Constructor : SyntaxKind + + GetAccessor = 128, +>GetAccessor : SyntaxKind + + SetAccessor = 129, +>SetAccessor : SyntaxKind + + CallSignature = 130, +>CallSignature : SyntaxKind + + ConstructSignature = 131, +>ConstructSignature : SyntaxKind + + IndexSignature = 132, +>IndexSignature : SyntaxKind + + TypeReference = 133, +>TypeReference : SyntaxKind + + FunctionType = 134, +>FunctionType : SyntaxKind + + ConstructorType = 135, +>ConstructorType : SyntaxKind + + TypeQuery = 136, +>TypeQuery : SyntaxKind + + TypeLiteral = 137, +>TypeLiteral : SyntaxKind + + ArrayType = 138, +>ArrayType : SyntaxKind + + TupleType = 139, +>TupleType : SyntaxKind + + UnionType = 140, +>UnionType : SyntaxKind + + ParenthesizedType = 141, +>ParenthesizedType : SyntaxKind + + ArrayLiteralExpression = 142, +>ArrayLiteralExpression : SyntaxKind + + ObjectLiteralExpression = 143, +>ObjectLiteralExpression : SyntaxKind + + PropertyAccessExpression = 144, +>PropertyAccessExpression : SyntaxKind + + ElementAccessExpression = 145, +>ElementAccessExpression : SyntaxKind + + CallExpression = 146, +>CallExpression : SyntaxKind + + NewExpression = 147, +>NewExpression : SyntaxKind + + TaggedTemplateExpression = 148, +>TaggedTemplateExpression : SyntaxKind + + TypeAssertionExpression = 149, +>TypeAssertionExpression : SyntaxKind + + ParenthesizedExpression = 150, +>ParenthesizedExpression : SyntaxKind + + FunctionExpression = 151, +>FunctionExpression : SyntaxKind + + ArrowFunction = 152, +>ArrowFunction : SyntaxKind + + DeleteExpression = 153, +>DeleteExpression : SyntaxKind + + TypeOfExpression = 154, +>TypeOfExpression : SyntaxKind + + VoidExpression = 155, +>VoidExpression : SyntaxKind + + PrefixUnaryExpression = 156, +>PrefixUnaryExpression : SyntaxKind + + PostfixUnaryExpression = 157, +>PostfixUnaryExpression : SyntaxKind + + BinaryExpression = 158, +>BinaryExpression : SyntaxKind + + ConditionalExpression = 159, +>ConditionalExpression : SyntaxKind + + TemplateExpression = 160, +>TemplateExpression : SyntaxKind + + YieldExpression = 161, +>YieldExpression : SyntaxKind + + OmittedExpression = 162, +>OmittedExpression : SyntaxKind + + TemplateSpan = 163, +>TemplateSpan : SyntaxKind + + Block = 164, +>Block : SyntaxKind + + VariableStatement = 165, +>VariableStatement : SyntaxKind + + EmptyStatement = 166, +>EmptyStatement : SyntaxKind + + ExpressionStatement = 167, +>ExpressionStatement : SyntaxKind + + IfStatement = 168, +>IfStatement : SyntaxKind + + DoStatement = 169, +>DoStatement : SyntaxKind + + WhileStatement = 170, +>WhileStatement : SyntaxKind + + ForStatement = 171, +>ForStatement : SyntaxKind + + ForInStatement = 172, +>ForInStatement : SyntaxKind + + ContinueStatement = 173, +>ContinueStatement : SyntaxKind + + BreakStatement = 174, +>BreakStatement : SyntaxKind + + ReturnStatement = 175, +>ReturnStatement : SyntaxKind + + WithStatement = 176, +>WithStatement : SyntaxKind + + SwitchStatement = 177, +>SwitchStatement : SyntaxKind + + LabeledStatement = 178, +>LabeledStatement : SyntaxKind + + ThrowStatement = 179, +>ThrowStatement : SyntaxKind + + TryStatement = 180, +>TryStatement : SyntaxKind + + TryBlock = 181, +>TryBlock : SyntaxKind + + CatchBlock = 182, +>CatchBlock : SyntaxKind + + FinallyBlock = 183, +>FinallyBlock : SyntaxKind + + DebuggerStatement = 184, +>DebuggerStatement : SyntaxKind + + VariableDeclaration = 185, +>VariableDeclaration : SyntaxKind + + FunctionDeclaration = 186, +>FunctionDeclaration : SyntaxKind + + FunctionBlock = 187, +>FunctionBlock : SyntaxKind + + ClassDeclaration = 188, +>ClassDeclaration : SyntaxKind + + InterfaceDeclaration = 189, +>InterfaceDeclaration : SyntaxKind + + TypeAliasDeclaration = 190, +>TypeAliasDeclaration : SyntaxKind + + EnumDeclaration = 191, +>EnumDeclaration : SyntaxKind + + ModuleDeclaration = 192, +>ModuleDeclaration : SyntaxKind + + ModuleBlock = 193, +>ModuleBlock : SyntaxKind + + ImportDeclaration = 194, +>ImportDeclaration : SyntaxKind + + ExportAssignment = 195, +>ExportAssignment : SyntaxKind + + CaseClause = 196, +>CaseClause : SyntaxKind + + DefaultClause = 197, +>DefaultClause : SyntaxKind + + HeritageClause = 198, +>HeritageClause : SyntaxKind + + PropertyAssignment = 199, +>PropertyAssignment : SyntaxKind + + ShorthandPropertyAssignment = 200, +>ShorthandPropertyAssignment : SyntaxKind + + EnumMember = 201, +>EnumMember : SyntaxKind + + SourceFile = 202, +>SourceFile : SyntaxKind + + Program = 203, +>Program : SyntaxKind + + SyntaxList = 204, +>SyntaxList : SyntaxKind + + Count = 205, +>Count : SyntaxKind + + FirstAssignment = 51, +>FirstAssignment : SyntaxKind + + LastAssignment = 62, +>LastAssignment : SyntaxKind + + FirstReservedWord = 64, +>FirstReservedWord : SyntaxKind + + LastReservedWord = 99, +>LastReservedWord : SyntaxKind + + FirstKeyword = 64, +>FirstKeyword : SyntaxKind + + LastKeyword = 119, +>LastKeyword : SyntaxKind + + FirstFutureReservedWord = 100, +>FirstFutureReservedWord : SyntaxKind + + LastFutureReservedWord = 108, +>LastFutureReservedWord : SyntaxKind + + FirstTypeNode = 133, +>FirstTypeNode : SyntaxKind + + LastTypeNode = 141, +>LastTypeNode : SyntaxKind + + FirstPunctuation = 13, +>FirstPunctuation : SyntaxKind + + LastPunctuation = 62, +>LastPunctuation : SyntaxKind + + FirstToken = 1, +>FirstToken : SyntaxKind + + LastToken = 119, +>LastToken : SyntaxKind + + FirstTriviaToken = 2, +>FirstTriviaToken : SyntaxKind + + LastTriviaToken = 5, +>LastTriviaToken : SyntaxKind + + FirstLiteralToken = 6, +>FirstLiteralToken : SyntaxKind + + LastLiteralToken = 9, +>LastLiteralToken : SyntaxKind + + FirstTemplateToken = 9, +>FirstTemplateToken : SyntaxKind + + LastTemplateToken = 12, +>LastTemplateToken : SyntaxKind + + FirstOperator = 21, +>FirstOperator : SyntaxKind + + LastOperator = 62, +>LastOperator : SyntaxKind + + FirstBinaryOperator = 23, +>FirstBinaryOperator : SyntaxKind + + LastBinaryOperator = 62, +>LastBinaryOperator : SyntaxKind + } + const enum NodeFlags { +>NodeFlags : NodeFlags + + Export = 1, +>Export : NodeFlags + + Ambient = 2, +>Ambient : NodeFlags + + QuestionMark = 4, +>QuestionMark : NodeFlags + + Rest = 8, +>Rest : NodeFlags + + Public = 16, +>Public : NodeFlags + + Private = 32, +>Private : NodeFlags + + Protected = 64, +>Protected : NodeFlags + + Static = 128, +>Static : NodeFlags + + MultiLine = 256, +>MultiLine : NodeFlags + + Synthetic = 512, +>Synthetic : NodeFlags + + DeclarationFile = 1024, +>DeclarationFile : NodeFlags + + Let = 2048, +>Let : NodeFlags + + Const = 4096, +>Const : NodeFlags + + OctalLiteral = 8192, +>OctalLiteral : NodeFlags + + Modifier = 243, +>Modifier : NodeFlags + + AccessibilityModifier = 112, +>AccessibilityModifier : NodeFlags + + BlockScoped = 6144, +>BlockScoped : NodeFlags + } + const enum ParserContextFlags { +>ParserContextFlags : ParserContextFlags + + StrictMode = 1, +>StrictMode : ParserContextFlags + + DisallowIn = 2, +>DisallowIn : ParserContextFlags + + Yield = 4, +>Yield : ParserContextFlags + + GeneratorParameter = 8, +>GeneratorParameter : ParserContextFlags + } + interface Node extends TextRange { +>Node : Node +>TextRange : TextRange + + kind: SyntaxKind; +>kind : SyntaxKind +>SyntaxKind : SyntaxKind + + flags: NodeFlags; +>flags : NodeFlags +>NodeFlags : NodeFlags + + parserContextFlags?: ParserContextFlags; +>parserContextFlags : ParserContextFlags +>ParserContextFlags : ParserContextFlags + + id?: number; +>id : number + + parent?: Node; +>parent : Node +>Node : Node + + symbol?: Symbol; +>symbol : Symbol +>Symbol : Symbol + + locals?: SymbolTable; +>locals : SymbolTable +>SymbolTable : SymbolTable + + nextContainer?: Node; +>nextContainer : Node +>Node : Node + + localSymbol?: Symbol; +>localSymbol : Symbol +>Symbol : Symbol + + modifiers?: ModifiersArray; +>modifiers : ModifiersArray +>ModifiersArray : ModifiersArray + } + interface NodeArray extends Array, TextRange { +>NodeArray : NodeArray +>T : T +>Array : T[] +>T : T +>TextRange : TextRange + + hasTrailingComma?: boolean; +>hasTrailingComma : boolean + } + interface ModifiersArray extends Array { +>ModifiersArray : ModifiersArray +>Array : T[] +>Node : Node + + flags: number; +>flags : number + } + interface Identifier extends PrimaryExpression { +>Identifier : Identifier +>PrimaryExpression : PrimaryExpression + + text: string; +>text : string + } + interface QualifiedName extends Node { +>QualifiedName : QualifiedName +>Node : Node + + left: EntityName; +>left : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + + right: Identifier; +>right : Identifier +>Identifier : Identifier + } + type EntityName = Identifier | QualifiedName; +>EntityName : Identifier | QualifiedName +>Identifier : Identifier +>QualifiedName : QualifiedName + + interface ParsedSignature { +>ParsedSignature : ParsedSignature + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + parameters: NodeArray; +>parameters : NodeArray +>NodeArray : NodeArray +>ParameterDeclaration : ParameterDeclaration + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName +>Identifier : Identifier +>LiteralExpression : LiteralExpression +>ComputedPropertyName : ComputedPropertyName + + interface Declaration extends Node { +>Declaration : Declaration +>Node : Node + + _declarationBrand: any; +>_declarationBrand : any + + name?: DeclarationName; +>name : Identifier | LiteralExpression | ComputedPropertyName +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName + } + interface ComputedPropertyName extends Node { +>ComputedPropertyName : ComputedPropertyName +>Node : Node + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface TypeParameterDeclaration extends Declaration { +>TypeParameterDeclaration : TypeParameterDeclaration +>Declaration : Declaration + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + constraint?: TypeNode; +>constraint : TypeNode +>TypeNode : TypeNode + + expression?: Expression; +>expression : Expression +>Expression : Expression + } + interface SignatureDeclaration extends Declaration, ParsedSignature { +>SignatureDeclaration : SignatureDeclaration +>Declaration : Declaration +>ParsedSignature : ParsedSignature + } + interface VariableDeclaration extends Declaration { +>VariableDeclaration : VariableDeclaration +>Declaration : Declaration + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + } + interface PropertyDeclaration extends Declaration, ClassElement { +>PropertyDeclaration : PropertyDeclaration +>Declaration : Declaration +>ClassElement : ClassElement + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + } + interface ShortHandPropertyDeclaration extends Declaration { +>ShortHandPropertyDeclaration : ShortHandPropertyDeclaration +>Declaration : Declaration + + name: Identifier; +>name : Identifier +>Identifier : Identifier + } + interface ParameterDeclaration extends VariableDeclaration { +>ParameterDeclaration : ParameterDeclaration +>VariableDeclaration : VariableDeclaration + } + /** + * Several node kinds share function-like features such as a signature, + * a name, and a body. These nodes should extend FunctionLikeDeclaration. + * Examples: + * FunctionDeclaration + * MethodDeclaration + * AccessorDeclaration + */ + interface FunctionLikeDeclaration extends SignatureDeclaration { +>FunctionLikeDeclaration : FunctionLikeDeclaration +>SignatureDeclaration : SignatureDeclaration + + _functionLikeDeclarationBrand: any; +>_functionLikeDeclarationBrand : any + + asteriskToken?: Node; +>asteriskToken : Node +>Node : Node + + body?: Block | Expression; +>body : Expression | Block +>Block : Block +>Expression : Expression + } + interface FunctionDeclaration extends FunctionLikeDeclaration, Statement { +>FunctionDeclaration : FunctionDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>Statement : Statement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + body?: Block; +>body : Block +>Block : Block + } + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { +>MethodDeclaration : MethodDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>ClassElement : ClassElement + + body?: Block; +>body : Block +>Block : Block + } + interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement { +>ConstructorDeclaration : ConstructorDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>ClassElement : ClassElement + + body?: Block; +>body : Block +>Block : Block + } + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { +>AccessorDeclaration : AccessorDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration +>ClassElement : ClassElement + + body?: Block; +>body : Block +>Block : Block + } + interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement { +>IndexSignatureDeclaration : IndexSignatureDeclaration +>SignatureDeclaration : SignatureDeclaration +>ClassElement : ClassElement + + _indexSignatureDeclarationBrand: any; +>_indexSignatureDeclarationBrand : any + } + interface TypeNode extends Node { +>TypeNode : TypeNode +>Node : Node + } + interface TypeReferenceNode extends TypeNode { +>TypeReferenceNode : TypeReferenceNode +>TypeNode : TypeNode + + typeName: EntityName; +>typeName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + + typeArguments?: NodeArray; +>typeArguments : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + } + interface TypeQueryNode extends TypeNode { +>TypeQueryNode : TypeQueryNode +>TypeNode : TypeNode + + exprName: EntityName; +>exprName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + } + interface TypeLiteralNode extends TypeNode, Declaration { +>TypeLiteralNode : TypeLiteralNode +>TypeNode : TypeNode +>Declaration : Declaration + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>Node : Node + } + interface ArrayTypeNode extends TypeNode { +>ArrayTypeNode : ArrayTypeNode +>TypeNode : TypeNode + + elementType: TypeNode; +>elementType : TypeNode +>TypeNode : TypeNode + } + interface TupleTypeNode extends TypeNode { +>TupleTypeNode : TupleTypeNode +>TypeNode : TypeNode + + elementTypes: NodeArray; +>elementTypes : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + } + interface UnionTypeNode extends TypeNode { +>UnionTypeNode : UnionTypeNode +>TypeNode : TypeNode + + types: NodeArray; +>types : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + } + interface ParenthesizedTypeNode extends TypeNode { +>ParenthesizedTypeNode : ParenthesizedTypeNode +>TypeNode : TypeNode + + type: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + interface StringLiteralTypeNode extends TypeNode { +>StringLiteralTypeNode : StringLiteralTypeNode +>TypeNode : TypeNode + + text: string; +>text : string + } + interface Expression extends Node { +>Expression : Expression +>Node : Node + + _expressionBrand: any; +>_expressionBrand : any + + contextualType?: Type; +>contextualType : Type +>Type : Type + } + interface UnaryExpression extends Expression { +>UnaryExpression : UnaryExpression +>Expression : Expression + + _unaryExpressionBrand: any; +>_unaryExpressionBrand : any + } + interface PrefixUnaryExpression extends UnaryExpression { +>PrefixUnaryExpression : PrefixUnaryExpression +>UnaryExpression : UnaryExpression + + operator: SyntaxKind; +>operator : SyntaxKind +>SyntaxKind : SyntaxKind + + operand: UnaryExpression; +>operand : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface PostfixUnaryExpression extends PostfixExpression { +>PostfixUnaryExpression : PostfixUnaryExpression +>PostfixExpression : PostfixExpression + + operand: LeftHandSideExpression; +>operand : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + operator: SyntaxKind; +>operator : SyntaxKind +>SyntaxKind : SyntaxKind + } + interface PostfixExpression extends UnaryExpression { +>PostfixExpression : PostfixExpression +>UnaryExpression : UnaryExpression + + _postfixExpressionBrand: any; +>_postfixExpressionBrand : any + } + interface LeftHandSideExpression extends PostfixExpression { +>LeftHandSideExpression : LeftHandSideExpression +>PostfixExpression : PostfixExpression + + _leftHandSideExpressionBrand: any; +>_leftHandSideExpressionBrand : any + } + interface MemberExpression extends LeftHandSideExpression { +>MemberExpression : MemberExpression +>LeftHandSideExpression : LeftHandSideExpression + + _memberExpressionBrand: any; +>_memberExpressionBrand : any + } + interface PrimaryExpression extends MemberExpression { +>PrimaryExpression : PrimaryExpression +>MemberExpression : MemberExpression + + _primaryExpressionBrand: any; +>_primaryExpressionBrand : any + } + interface DeleteExpression extends UnaryExpression { +>DeleteExpression : DeleteExpression +>UnaryExpression : UnaryExpression + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface TypeOfExpression extends UnaryExpression { +>TypeOfExpression : TypeOfExpression +>UnaryExpression : UnaryExpression + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface VoidExpression extends UnaryExpression { +>VoidExpression : VoidExpression +>UnaryExpression : UnaryExpression + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface YieldExpression extends Expression { +>YieldExpression : YieldExpression +>Expression : Expression + + asteriskToken?: Node; +>asteriskToken : Node +>Node : Node + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface BinaryExpression extends Expression { +>BinaryExpression : BinaryExpression +>Expression : Expression + + left: Expression; +>left : Expression +>Expression : Expression + + operator: SyntaxKind; +>operator : SyntaxKind +>SyntaxKind : SyntaxKind + + right: Expression; +>right : Expression +>Expression : Expression + } + interface ConditionalExpression extends Expression { +>ConditionalExpression : ConditionalExpression +>Expression : Expression + + condition: Expression; +>condition : Expression +>Expression : Expression + + whenTrue: Expression; +>whenTrue : Expression +>Expression : Expression + + whenFalse: Expression; +>whenFalse : Expression +>Expression : Expression + } + interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration { +>FunctionExpression : FunctionExpression +>PrimaryExpression : PrimaryExpression +>FunctionLikeDeclaration : FunctionLikeDeclaration + + name?: Identifier; +>name : Identifier +>Identifier : Identifier + + body: Block | Expression; +>body : Expression | Block +>Block : Block +>Expression : Expression + } + interface LiteralExpression extends PrimaryExpression { +>LiteralExpression : LiteralExpression +>PrimaryExpression : PrimaryExpression + + text: string; +>text : string + } + interface TemplateExpression extends PrimaryExpression { +>TemplateExpression : TemplateExpression +>PrimaryExpression : PrimaryExpression + + head: LiteralExpression; +>head : LiteralExpression +>LiteralExpression : LiteralExpression + + templateSpans: NodeArray; +>templateSpans : NodeArray +>NodeArray : NodeArray +>TemplateSpan : TemplateSpan + } + interface TemplateSpan extends Node { +>TemplateSpan : TemplateSpan +>Node : Node + + expression: Expression; +>expression : Expression +>Expression : Expression + + literal: LiteralExpression; +>literal : LiteralExpression +>LiteralExpression : LiteralExpression + } + interface ParenthesizedExpression extends PrimaryExpression { +>ParenthesizedExpression : ParenthesizedExpression +>PrimaryExpression : PrimaryExpression + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface ArrayLiteralExpression extends PrimaryExpression { +>ArrayLiteralExpression : ArrayLiteralExpression +>PrimaryExpression : PrimaryExpression + + elements: NodeArray; +>elements : NodeArray +>NodeArray : NodeArray +>Expression : Expression + } + interface ObjectLiteralExpression extends PrimaryExpression, Declaration { +>ObjectLiteralExpression : ObjectLiteralExpression +>PrimaryExpression : PrimaryExpression +>Declaration : Declaration + + properties: NodeArray; +>properties : NodeArray +>NodeArray : NodeArray +>Declaration : Declaration + } + interface PropertyAccessExpression extends MemberExpression { +>PropertyAccessExpression : PropertyAccessExpression +>MemberExpression : MemberExpression + + expression: LeftHandSideExpression; +>expression : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + name: Identifier; +>name : Identifier +>Identifier : Identifier + } + interface ElementAccessExpression extends MemberExpression { +>ElementAccessExpression : ElementAccessExpression +>MemberExpression : MemberExpression + + expression: LeftHandSideExpression; +>expression : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + argumentExpression: Expression; +>argumentExpression : Expression +>Expression : Expression + } + interface CallExpression extends LeftHandSideExpression { +>CallExpression : CallExpression +>LeftHandSideExpression : LeftHandSideExpression + + expression: LeftHandSideExpression; +>expression : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + typeArguments?: NodeArray; +>typeArguments : NodeArray +>NodeArray : NodeArray +>TypeNode : TypeNode + + arguments: NodeArray; +>arguments : NodeArray +>NodeArray : NodeArray +>Expression : Expression + } + interface NewExpression extends CallExpression, PrimaryExpression { +>NewExpression : NewExpression +>CallExpression : CallExpression +>PrimaryExpression : PrimaryExpression + } + interface TaggedTemplateExpression extends MemberExpression { +>TaggedTemplateExpression : TaggedTemplateExpression +>MemberExpression : MemberExpression + + tag: LeftHandSideExpression; +>tag : LeftHandSideExpression +>LeftHandSideExpression : LeftHandSideExpression + + template: LiteralExpression | TemplateExpression; +>template : LiteralExpression | TemplateExpression +>LiteralExpression : LiteralExpression +>TemplateExpression : TemplateExpression + } + type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression; +>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression +>CallExpression : CallExpression +>NewExpression : NewExpression +>TaggedTemplateExpression : TaggedTemplateExpression + + interface TypeAssertion extends UnaryExpression { +>TypeAssertion : TypeAssertion +>UnaryExpression : UnaryExpression + + type: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + + expression: UnaryExpression; +>expression : UnaryExpression +>UnaryExpression : UnaryExpression + } + interface Statement extends Node, ModuleElement { +>Statement : Statement +>Node : Node +>ModuleElement : ModuleElement + + _statementBrand: any; +>_statementBrand : any + } + interface Block extends Statement { +>Block : Block +>Statement : Statement + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>Statement : Statement + } + interface VariableStatement extends Statement { +>VariableStatement : VariableStatement +>Statement : Statement + + declarations: NodeArray; +>declarations : NodeArray +>NodeArray : NodeArray +>VariableDeclaration : VariableDeclaration + } + interface ExpressionStatement extends Statement { +>ExpressionStatement : ExpressionStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface IfStatement extends Statement { +>IfStatement : IfStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + + thenStatement: Statement; +>thenStatement : Statement +>Statement : Statement + + elseStatement?: Statement; +>elseStatement : Statement +>Statement : Statement + } + interface IterationStatement extends Statement { +>IterationStatement : IterationStatement +>Statement : Statement + + statement: Statement; +>statement : Statement +>Statement : Statement + } + interface DoStatement extends IterationStatement { +>DoStatement : DoStatement +>IterationStatement : IterationStatement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface WhileStatement extends IterationStatement { +>WhileStatement : WhileStatement +>IterationStatement : IterationStatement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface ForStatement extends IterationStatement { +>ForStatement : ForStatement +>IterationStatement : IterationStatement + + declarations?: NodeArray; +>declarations : NodeArray +>NodeArray : NodeArray +>VariableDeclaration : VariableDeclaration + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + + condition?: Expression; +>condition : Expression +>Expression : Expression + + iterator?: Expression; +>iterator : Expression +>Expression : Expression + } + interface ForInStatement extends IterationStatement { +>ForInStatement : ForInStatement +>IterationStatement : IterationStatement + + declarations?: NodeArray; +>declarations : NodeArray +>NodeArray : NodeArray +>VariableDeclaration : VariableDeclaration + + variable?: Expression; +>variable : Expression +>Expression : Expression + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface BreakOrContinueStatement extends Statement { +>BreakOrContinueStatement : BreakOrContinueStatement +>Statement : Statement + + label?: Identifier; +>label : Identifier +>Identifier : Identifier + } + interface ReturnStatement extends Statement { +>ReturnStatement : ReturnStatement +>Statement : Statement + + expression?: Expression; +>expression : Expression +>Expression : Expression + } + interface WithStatement extends Statement { +>WithStatement : WithStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + + statement: Statement; +>statement : Statement +>Statement : Statement + } + interface SwitchStatement extends Statement { +>SwitchStatement : SwitchStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + + clauses: NodeArray; +>clauses : NodeArray +>NodeArray : NodeArray +>CaseOrDefaultClause : CaseOrDefaultClause + } + interface CaseOrDefaultClause extends Node { +>CaseOrDefaultClause : CaseOrDefaultClause +>Node : Node + + expression?: Expression; +>expression : Expression +>Expression : Expression + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>Statement : Statement + } + interface LabeledStatement extends Statement { +>LabeledStatement : LabeledStatement +>Statement : Statement + + label: Identifier; +>label : Identifier +>Identifier : Identifier + + statement: Statement; +>statement : Statement +>Statement : Statement + } + interface ThrowStatement extends Statement { +>ThrowStatement : ThrowStatement +>Statement : Statement + + expression: Expression; +>expression : Expression +>Expression : Expression + } + interface TryStatement extends Statement { +>TryStatement : TryStatement +>Statement : Statement + + tryBlock: Block; +>tryBlock : Block +>Block : Block + + catchBlock?: CatchBlock; +>catchBlock : CatchBlock +>CatchBlock : CatchBlock + + finallyBlock?: Block; +>finallyBlock : Block +>Block : Block + } + interface CatchBlock extends Block, Declaration { +>CatchBlock : CatchBlock +>Block : Block +>Declaration : Declaration + + variable: Identifier; +>variable : Identifier +>Identifier : Identifier + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + interface ModuleElement extends Node { +>ModuleElement : ModuleElement +>Node : Node + + _moduleElementBrand: any; +>_moduleElementBrand : any + } + interface ClassDeclaration extends Declaration, ModuleElement { +>ClassDeclaration : ClassDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + heritageClauses?: NodeArray; +>heritageClauses : NodeArray +>NodeArray : NodeArray +>HeritageClause : HeritageClause + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>ClassElement : ClassElement + } + interface ClassElement extends Declaration { +>ClassElement : ClassElement +>Declaration : Declaration + + _classElementBrand: any; +>_classElementBrand : any + } + interface InterfaceDeclaration extends Declaration, ModuleElement { +>InterfaceDeclaration : InterfaceDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + heritageClauses?: NodeArray; +>heritageClauses : NodeArray +>NodeArray : NodeArray +>HeritageClause : HeritageClause + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>Declaration : Declaration + } + interface HeritageClause extends Node { +>HeritageClause : HeritageClause +>Node : Node + + token: SyntaxKind; +>token : SyntaxKind +>SyntaxKind : SyntaxKind + + types?: NodeArray; +>types : NodeArray +>NodeArray : NodeArray +>TypeReferenceNode : TypeReferenceNode + } + interface TypeAliasDeclaration extends Declaration, ModuleElement { +>TypeAliasDeclaration : TypeAliasDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + type: TypeNode; +>type : TypeNode +>TypeNode : TypeNode + } + interface EnumMember extends Declaration { +>EnumMember : EnumMember +>Declaration : Declaration + + name: DeclarationName; +>name : Identifier | LiteralExpression | ComputedPropertyName +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName + + initializer?: Expression; +>initializer : Expression +>Expression : Expression + } + interface EnumDeclaration extends Declaration, ModuleElement { +>EnumDeclaration : EnumDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + members: NodeArray; +>members : NodeArray +>NodeArray : NodeArray +>EnumMember : EnumMember + } + interface ModuleDeclaration extends Declaration, ModuleElement { +>ModuleDeclaration : ModuleDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier | LiteralExpression; +>name : Identifier | LiteralExpression +>Identifier : Identifier +>LiteralExpression : LiteralExpression + + body: ModuleBlock | ModuleDeclaration; +>body : ModuleDeclaration | ModuleBlock +>ModuleBlock : ModuleBlock +>ModuleDeclaration : ModuleDeclaration + } + interface ModuleBlock extends Node, ModuleElement { +>ModuleBlock : ModuleBlock +>Node : Node +>ModuleElement : ModuleElement + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>ModuleElement : ModuleElement + } + interface ImportDeclaration extends Declaration, ModuleElement { +>ImportDeclaration : ImportDeclaration +>Declaration : Declaration +>ModuleElement : ModuleElement + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + entityName?: EntityName; +>entityName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName + + externalModuleName?: LiteralExpression; +>externalModuleName : LiteralExpression +>LiteralExpression : LiteralExpression + } + interface ExportAssignment extends Statement, ModuleElement { +>ExportAssignment : ExportAssignment +>Statement : Statement +>ModuleElement : ModuleElement + + exportName: Identifier; +>exportName : Identifier +>Identifier : Identifier + } + interface FileReference extends TextRange { +>FileReference : FileReference +>TextRange : TextRange + + filename: string; +>filename : string + } + interface CommentRange extends TextRange { +>CommentRange : CommentRange +>TextRange : TextRange + + hasTrailingNewLine?: boolean; +>hasTrailingNewLine : boolean + } + interface SourceFile extends Declaration { +>SourceFile : SourceFile +>Declaration : Declaration + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>ModuleElement : ModuleElement + + filename: string; +>filename : string + + text: string; +>text : string + + getLineAndCharacterFromPosition(position: number): LineAndCharacter; +>getLineAndCharacterFromPosition : (position: number) => LineAndCharacter +>position : number +>LineAndCharacter : LineAndCharacter + + getPositionFromLineAndCharacter(line: number, character: number): number; +>getPositionFromLineAndCharacter : (line: number, character: number) => number +>line : number +>character : number + + getLineStarts(): number[]; +>getLineStarts : () => number[] + + amdDependencies: string[]; +>amdDependencies : string[] + + amdModuleName: string; +>amdModuleName : string + + referencedFiles: FileReference[]; +>referencedFiles : FileReference[] +>FileReference : FileReference + + semanticDiagnostics: Diagnostic[]; +>semanticDiagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + parseDiagnostics: Diagnostic[]; +>parseDiagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + grammarDiagnostics: Diagnostic[]; +>grammarDiagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + getSyntacticDiagnostics(): Diagnostic[]; +>getSyntacticDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + hasNoDefaultLib: boolean; +>hasNoDefaultLib : boolean + + externalModuleIndicator: Node; +>externalModuleIndicator : Node +>Node : Node + + nodeCount: number; +>nodeCount : number + + identifierCount: number; +>identifierCount : number + + symbolCount: number; +>symbolCount : number + + isOpen: boolean; +>isOpen : boolean + + version: string; +>version : string + + languageVersion: ScriptTarget; +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget + + identifiers: Map; +>identifiers : Map +>Map : Map + } + interface Program { +>Program : Program + + getSourceFile(filename: string): SourceFile; +>getSourceFile : (filename: string) => SourceFile +>filename : string +>SourceFile : SourceFile + + getSourceFiles(): SourceFile[]; +>getSourceFiles : () => SourceFile[] +>SourceFile : SourceFile + + getCompilerOptions(): CompilerOptions; +>getCompilerOptions : () => CompilerOptions +>CompilerOptions : CompilerOptions + + getCompilerHost(): CompilerHost; +>getCompilerHost : () => CompilerHost +>CompilerHost : CompilerHost + + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; +>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Diagnostic : Diagnostic + + getGlobalDiagnostics(): Diagnostic[]; +>getGlobalDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + getTypeChecker(fullTypeCheckMode: boolean): TypeChecker; +>getTypeChecker : (fullTypeCheckMode: boolean) => TypeChecker +>fullTypeCheckMode : boolean +>TypeChecker : TypeChecker + + getCommonSourceDirectory(): string; +>getCommonSourceDirectory : () => string + } + interface SourceMapSpan { +>SourceMapSpan : SourceMapSpan + + emittedLine: number; +>emittedLine : number + + emittedColumn: number; +>emittedColumn : number + + sourceLine: number; +>sourceLine : number + + sourceColumn: number; +>sourceColumn : number + + nameIndex?: number; +>nameIndex : number + + sourceIndex: number; +>sourceIndex : number + } + interface SourceMapData { +>SourceMapData : SourceMapData + + sourceMapFilePath: string; +>sourceMapFilePath : string + + jsSourceMappingURL: string; +>jsSourceMappingURL : string + + sourceMapFile: string; +>sourceMapFile : string + + sourceMapSourceRoot: string; +>sourceMapSourceRoot : string + + sourceMapSources: string[]; +>sourceMapSources : string[] + + inputSourceFileNames: string[]; +>inputSourceFileNames : string[] + + sourceMapNames?: string[]; +>sourceMapNames : string[] + + sourceMapMappings: string; +>sourceMapMappings : string + + sourceMapDecodedMappings: SourceMapSpan[]; +>sourceMapDecodedMappings : SourceMapSpan[] +>SourceMapSpan : SourceMapSpan + } + enum EmitReturnStatus { +>EmitReturnStatus : EmitReturnStatus + + Succeeded = 0, +>Succeeded : EmitReturnStatus + + AllOutputGenerationSkipped = 1, +>AllOutputGenerationSkipped : EmitReturnStatus + + JSGeneratedWithSemanticErrors = 2, +>JSGeneratedWithSemanticErrors : EmitReturnStatus + + DeclarationGenerationSkipped = 3, +>DeclarationGenerationSkipped : EmitReturnStatus + + EmitErrorsEncountered = 4, +>EmitErrorsEncountered : EmitReturnStatus + + CompilerOptionsErrors = 5, +>CompilerOptionsErrors : EmitReturnStatus + } + interface EmitResult { +>EmitResult : EmitResult + + emitResultStatus: EmitReturnStatus; +>emitResultStatus : EmitReturnStatus +>EmitReturnStatus : EmitReturnStatus + + diagnostics: Diagnostic[]; +>diagnostics : Diagnostic[] +>Diagnostic : Diagnostic + + sourceMaps: SourceMapData[]; +>sourceMaps : SourceMapData[] +>SourceMapData : SourceMapData + } + interface TypeChecker { +>TypeChecker : TypeChecker + + getProgram(): Program; +>getProgram : () => Program +>Program : Program + + getDiagnostics(sourceFile?: SourceFile): Diagnostic[]; +>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Diagnostic : Diagnostic + + getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[]; +>getDeclarationDiagnostics : (sourceFile: SourceFile) => Diagnostic[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Diagnostic : Diagnostic + + getGlobalDiagnostics(): Diagnostic[]; +>getGlobalDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + getNodeCount(): number; +>getNodeCount : () => number + + getIdentifierCount(): number; +>getIdentifierCount : () => number + + getSymbolCount(): number; +>getSymbolCount : () => number + + getTypeCount(): number; +>getTypeCount : () => number + + checkProgram(): void; +>checkProgram : () => void + + emitFiles(targetSourceFile?: SourceFile): EmitResult; +>emitFiles : (targetSourceFile?: SourceFile) => EmitResult +>targetSourceFile : SourceFile +>SourceFile : SourceFile +>EmitResult : EmitResult + + getParentOfSymbol(symbol: Symbol): Symbol; +>getParentOfSymbol : (symbol: Symbol) => Symbol +>symbol : Symbol +>Symbol : Symbol +>Symbol : Symbol + + getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; +>getNarrowedTypeOfSymbol : (symbol: Symbol, node: Node) => Type +>symbol : Symbol +>Symbol : Symbol +>node : Node +>Node : Node +>Type : Type + + getDeclaredTypeOfSymbol(symbol: Symbol): Type; +>getDeclaredTypeOfSymbol : (symbol: Symbol) => Type +>symbol : Symbol +>Symbol : Symbol +>Type : Type + + getPropertiesOfType(type: Type): Symbol[]; +>getPropertiesOfType : (type: Type) => Symbol[] +>type : Type +>Type : Type +>Symbol : Symbol + + getPropertyOfType(type: Type, propertyName: string): Symbol; +>getPropertyOfType : (type: Type, propertyName: string) => Symbol +>type : Type +>Type : Type +>propertyName : string +>Symbol : Symbol + + getSignaturesOfType(type: Type, kind: SignatureKind): Signature[]; +>getSignaturesOfType : (type: Type, kind: SignatureKind) => Signature[] +>type : Type +>Type : Type +>kind : SignatureKind +>SignatureKind : SignatureKind +>Signature : Signature + + getIndexTypeOfType(type: Type, kind: IndexKind): Type; +>getIndexTypeOfType : (type: Type, kind: IndexKind) => Type +>type : Type +>Type : Type +>kind : IndexKind +>IndexKind : IndexKind +>Type : Type + + getReturnTypeOfSignature(signature: Signature): Type; +>getReturnTypeOfSignature : (signature: Signature) => Type +>signature : Signature +>Signature : Signature +>Type : Type + + getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; +>getSymbolsInScope : (location: Node, meaning: SymbolFlags) => Symbol[] +>location : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags +>Symbol : Symbol + + getSymbolInfo(node: Node): Symbol; +>getSymbolInfo : (node: Node) => Symbol +>node : Node +>Node : Node +>Symbol : Symbol + + getShorthandAssignmentValueSymbol(location: Node): Symbol; +>getShorthandAssignmentValueSymbol : (location: Node) => Symbol +>location : Node +>Node : Node +>Symbol : Symbol + + getTypeOfNode(node: Node): Type; +>getTypeOfNode : (node: Node) => Type +>node : Node +>Node : Node +>Type : Type + + typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; +>typeToString : (type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => string +>type : Type +>Type : Type +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; +>symbolToString : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => string +>symbol : Symbol +>Symbol : Symbol +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags + + getSymbolDisplayBuilder(): SymbolDisplayBuilder; +>getSymbolDisplayBuilder : () => SymbolDisplayBuilder +>SymbolDisplayBuilder : SymbolDisplayBuilder + + getFullyQualifiedName(symbol: Symbol): string; +>getFullyQualifiedName : (symbol: Symbol) => string +>symbol : Symbol +>Symbol : Symbol + + getAugmentedPropertiesOfType(type: Type): Symbol[]; +>getAugmentedPropertiesOfType : (type: Type) => Symbol[] +>type : Type +>Type : Type +>Symbol : Symbol + + getRootSymbols(symbol: Symbol): Symbol[]; +>getRootSymbols : (symbol: Symbol) => Symbol[] +>symbol : Symbol +>Symbol : Symbol +>Symbol : Symbol + + getContextualType(node: Node): Type; +>getContextualType : (node: Node) => Type +>node : Node +>Node : Node +>Type : Type + + getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; +>getResolvedSignature : (node: CallExpression | NewExpression | TaggedTemplateExpression, candidatesOutArray?: Signature[]) => Signature +>node : CallExpression | NewExpression | TaggedTemplateExpression +>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression +>candidatesOutArray : Signature[] +>Signature : Signature +>Signature : Signature + + getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature; +>getSignatureFromDeclaration : (declaration: SignatureDeclaration) => Signature +>declaration : SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration +>Signature : Signature + + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; +>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean +>node : FunctionLikeDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration + + isUndefinedSymbol(symbol: Symbol): boolean; +>isUndefinedSymbol : (symbol: Symbol) => boolean +>symbol : Symbol +>Symbol : Symbol + + isArgumentsSymbol(symbol: Symbol): boolean; +>isArgumentsSymbol : (symbol: Symbol) => boolean +>symbol : Symbol +>Symbol : Symbol + + isEmitBlocked(sourceFile?: SourceFile): boolean; +>isEmitBlocked : (sourceFile?: SourceFile) => boolean +>sourceFile : SourceFile +>SourceFile : SourceFile + + getEnumMemberValue(node: EnumMember): number; +>getEnumMemberValue : (node: EnumMember) => number +>node : EnumMember +>EnumMember : EnumMember + + isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; +>isValidPropertyAccess : (node: QualifiedName | PropertyAccessExpression, propertyName: string) => boolean +>node : QualifiedName | PropertyAccessExpression +>PropertyAccessExpression : PropertyAccessExpression +>QualifiedName : QualifiedName +>propertyName : string + + getAliasedSymbol(symbol: Symbol): Symbol; +>getAliasedSymbol : (symbol: Symbol) => Symbol +>symbol : Symbol +>Symbol : Symbol +>Symbol : Symbol + } + interface SymbolDisplayBuilder { +>SymbolDisplayBuilder : SymbolDisplayBuilder + + buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildTypeDisplay : (type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>type : Type +>Type : Type +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void; +>buildSymbolDisplay : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags) => void +>symbol : Symbol +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags +>flags : SymbolFormatFlags +>SymbolFormatFlags : SymbolFormatFlags + + buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildSignatureDisplay : (signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>signatures : Signature +>Signature : Signature +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildParameterDisplay : (parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>parameter : Symbol +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildTypeParameterDisplay : (tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>tp : TypeParameter +>TypeParameter : TypeParameter +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void; +>buildTypeParameterDisplayFromSymbol : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags) => void +>symbol : Symbol +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaraiton : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildDisplayForParametersAndDelimiters : (parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>parameters : Symbol[] +>Symbol : Symbol +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildDisplayForTypeParametersAndDelimiters : (typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + + buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; +>buildReturnTypeDisplay : (signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void +>signature : Signature +>Signature : Signature +>writer : SymbolWriter +>SymbolWriter : SymbolWriter +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags + } + interface SymbolWriter { +>SymbolWriter : SymbolWriter + + writeKeyword(text: string): void; +>writeKeyword : (text: string) => void +>text : string + + writeOperator(text: string): void; +>writeOperator : (text: string) => void +>text : string + + writePunctuation(text: string): void; +>writePunctuation : (text: string) => void +>text : string + + writeSpace(text: string): void; +>writeSpace : (text: string) => void +>text : string + + writeStringLiteral(text: string): void; +>writeStringLiteral : (text: string) => void +>text : string + + writeParameter(text: string): void; +>writeParameter : (text: string) => void +>text : string + + writeSymbol(text: string, symbol: Symbol): void; +>writeSymbol : (text: string, symbol: Symbol) => void +>text : string +>symbol : Symbol +>Symbol : Symbol + + writeLine(): void; +>writeLine : () => void + + increaseIndent(): void; +>increaseIndent : () => void + + decreaseIndent(): void; +>decreaseIndent : () => void + + clear(): void; +>clear : () => void + + trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void; +>trackSymbol : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => void +>symbol : Symbol +>Symbol : Symbol +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags + } + const enum TypeFormatFlags { +>TypeFormatFlags : TypeFormatFlags + + None = 0, +>None : TypeFormatFlags + + WriteArrayAsGenericType = 1, +>WriteArrayAsGenericType : TypeFormatFlags + + UseTypeOfFunction = 2, +>UseTypeOfFunction : TypeFormatFlags + + NoTruncation = 4, +>NoTruncation : TypeFormatFlags + + WriteArrowStyleSignature = 8, +>WriteArrowStyleSignature : TypeFormatFlags + + WriteOwnNameForAnyLike = 16, +>WriteOwnNameForAnyLike : TypeFormatFlags + + WriteTypeArgumentsOfSignature = 32, +>WriteTypeArgumentsOfSignature : TypeFormatFlags + + InElementType = 64, +>InElementType : TypeFormatFlags + } + const enum SymbolFormatFlags { +>SymbolFormatFlags : SymbolFormatFlags + + None = 0, +>None : SymbolFormatFlags + + WriteTypeParametersOrArguments = 1, +>WriteTypeParametersOrArguments : SymbolFormatFlags + + UseOnlyExternalAliasing = 2, +>UseOnlyExternalAliasing : SymbolFormatFlags + } + const enum SymbolAccessibility { +>SymbolAccessibility : SymbolAccessibility + + Accessible = 0, +>Accessible : SymbolAccessibility + + NotAccessible = 1, +>NotAccessible : SymbolAccessibility + + CannotBeNamed = 2, +>CannotBeNamed : SymbolAccessibility + } + interface SymbolVisibilityResult { +>SymbolVisibilityResult : SymbolVisibilityResult + + accessibility: SymbolAccessibility; +>accessibility : SymbolAccessibility +>SymbolAccessibility : SymbolAccessibility + + aliasesToMakeVisible?: ImportDeclaration[]; +>aliasesToMakeVisible : ImportDeclaration[] +>ImportDeclaration : ImportDeclaration + + errorSymbolName?: string; +>errorSymbolName : string + + errorNode?: Node; +>errorNode : Node +>Node : Node + } + interface SymbolAccessiblityResult extends SymbolVisibilityResult { +>SymbolAccessiblityResult : SymbolAccessiblityResult +>SymbolVisibilityResult : SymbolVisibilityResult + + errorModuleName?: string; +>errorModuleName : string + } + interface EmitResolver { +>EmitResolver : EmitResolver + + getProgram(): Program; +>getProgram : () => Program +>Program : Program + + getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string; +>getLocalNameOfContainer : (container: EnumDeclaration | ModuleDeclaration) => string +>container : EnumDeclaration | ModuleDeclaration +>ModuleDeclaration : ModuleDeclaration +>EnumDeclaration : EnumDeclaration + + getExpressionNamePrefix(node: Identifier): string; +>getExpressionNamePrefix : (node: Identifier) => string +>node : Identifier +>Identifier : Identifier + + getExportAssignmentName(node: SourceFile): string; +>getExportAssignmentName : (node: SourceFile) => string +>node : SourceFile +>SourceFile : SourceFile + + isReferencedImportDeclaration(node: ImportDeclaration): boolean; +>isReferencedImportDeclaration : (node: ImportDeclaration) => boolean +>node : ImportDeclaration +>ImportDeclaration : ImportDeclaration + + isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; +>isTopLevelValueImportWithEntityName : (node: ImportDeclaration) => boolean +>node : ImportDeclaration +>ImportDeclaration : ImportDeclaration + + getNodeCheckFlags(node: Node): NodeCheckFlags; +>getNodeCheckFlags : (node: Node) => NodeCheckFlags +>node : Node +>Node : Node +>NodeCheckFlags : NodeCheckFlags + + getEnumMemberValue(node: EnumMember): number; +>getEnumMemberValue : (node: EnumMember) => number +>node : EnumMember +>EnumMember : EnumMember + + hasSemanticErrors(): boolean; +>hasSemanticErrors : () => boolean + + isDeclarationVisible(node: Declaration): boolean; +>isDeclarationVisible : (node: Declaration) => boolean +>node : Declaration +>Declaration : Declaration + + isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; +>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean +>node : FunctionLikeDeclaration +>FunctionLikeDeclaration : FunctionLikeDeclaration + + writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; +>writeTypeAtLocation : (location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void +>location : Node +>Node : Node +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags +>writer : SymbolWriter +>SymbolWriter : SymbolWriter + + writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; +>writeReturnTypeOfSignatureDeclaration : (signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void +>signatureDeclaration : SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration +>enclosingDeclaration : Node +>Node : Node +>flags : TypeFormatFlags +>TypeFormatFlags : TypeFormatFlags +>writer : SymbolWriter +>SymbolWriter : SymbolWriter + + isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult; +>isSymbolAccessible : (symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) => SymbolAccessiblityResult +>symbol : Symbol +>Symbol : Symbol +>enclosingDeclaration : Node +>Node : Node +>meaning : SymbolFlags +>SymbolFlags : SymbolFlags +>SymbolAccessiblityResult : SymbolAccessiblityResult + + isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult; +>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult +>entityName : Identifier | QualifiedName +>EntityName : Identifier | QualifiedName +>enclosingDeclaration : Node +>Node : Node +>SymbolVisibilityResult : SymbolVisibilityResult + + getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number; +>getConstantValue : (node: PropertyAccessExpression | ElementAccessExpression) => number +>node : PropertyAccessExpression | ElementAccessExpression +>PropertyAccessExpression : PropertyAccessExpression +>ElementAccessExpression : ElementAccessExpression + + isEmitBlocked(sourceFile?: SourceFile): boolean; +>isEmitBlocked : (sourceFile?: SourceFile) => boolean +>sourceFile : SourceFile +>SourceFile : SourceFile + } + const enum SymbolFlags { +>SymbolFlags : SymbolFlags + + FunctionScopedVariable = 1, +>FunctionScopedVariable : SymbolFlags + + BlockScopedVariable = 2, +>BlockScopedVariable : SymbolFlags + + Property = 4, +>Property : SymbolFlags + + EnumMember = 8, +>EnumMember : SymbolFlags + + Function = 16, +>Function : SymbolFlags + + Class = 32, +>Class : SymbolFlags + + Interface = 64, +>Interface : SymbolFlags + + ConstEnum = 128, +>ConstEnum : SymbolFlags + + RegularEnum = 256, +>RegularEnum : SymbolFlags + + ValueModule = 512, +>ValueModule : SymbolFlags + + NamespaceModule = 1024, +>NamespaceModule : SymbolFlags + + TypeLiteral = 2048, +>TypeLiteral : SymbolFlags + + ObjectLiteral = 4096, +>ObjectLiteral : SymbolFlags + + Method = 8192, +>Method : SymbolFlags + + Constructor = 16384, +>Constructor : SymbolFlags + + GetAccessor = 32768, +>GetAccessor : SymbolFlags + + SetAccessor = 65536, +>SetAccessor : SymbolFlags + + CallSignature = 131072, +>CallSignature : SymbolFlags + + ConstructSignature = 262144, +>ConstructSignature : SymbolFlags + + IndexSignature = 524288, +>IndexSignature : SymbolFlags + + TypeParameter = 1048576, +>TypeParameter : SymbolFlags + + TypeAlias = 2097152, +>TypeAlias : SymbolFlags + + ExportValue = 4194304, +>ExportValue : SymbolFlags + + ExportType = 8388608, +>ExportType : SymbolFlags + + ExportNamespace = 16777216, +>ExportNamespace : SymbolFlags + + Import = 33554432, +>Import : SymbolFlags + + Instantiated = 67108864, +>Instantiated : SymbolFlags + + Merged = 134217728, +>Merged : SymbolFlags + + Transient = 268435456, +>Transient : SymbolFlags + + Prototype = 536870912, +>Prototype : SymbolFlags + + UnionProperty = 1073741824, +>UnionProperty : SymbolFlags + + Enum = 384, +>Enum : SymbolFlags + + Variable = 3, +>Variable : SymbolFlags + + Value = 107455, +>Value : SymbolFlags + + Type = 3152352, +>Type : SymbolFlags + + Namespace = 1536, +>Namespace : SymbolFlags + + Module = 1536, +>Module : SymbolFlags + + Accessor = 98304, +>Accessor : SymbolFlags + + Signature = 917504, +>Signature : SymbolFlags + + FunctionScopedVariableExcludes = 107454, +>FunctionScopedVariableExcludes : SymbolFlags + + BlockScopedVariableExcludes = 107455, +>BlockScopedVariableExcludes : SymbolFlags + + ParameterExcludes = 107455, +>ParameterExcludes : SymbolFlags + + PropertyExcludes = 107455, +>PropertyExcludes : SymbolFlags + + EnumMemberExcludes = 107455, +>EnumMemberExcludes : SymbolFlags + + FunctionExcludes = 106927, +>FunctionExcludes : SymbolFlags + + ClassExcludes = 3258879, +>ClassExcludes : SymbolFlags + + InterfaceExcludes = 3152288, +>InterfaceExcludes : SymbolFlags + + RegularEnumExcludes = 3258623, +>RegularEnumExcludes : SymbolFlags + + ConstEnumExcludes = 3259263, +>ConstEnumExcludes : SymbolFlags + + ValueModuleExcludes = 106639, +>ValueModuleExcludes : SymbolFlags + + NamespaceModuleExcludes = 0, +>NamespaceModuleExcludes : SymbolFlags + + MethodExcludes = 99263, +>MethodExcludes : SymbolFlags + + GetAccessorExcludes = 41919, +>GetAccessorExcludes : SymbolFlags + + SetAccessorExcludes = 74687, +>SetAccessorExcludes : SymbolFlags + + TypeParameterExcludes = 2103776, +>TypeParameterExcludes : SymbolFlags + + TypeAliasExcludes = 3152352, +>TypeAliasExcludes : SymbolFlags + + ImportExcludes = 33554432, +>ImportExcludes : SymbolFlags + + ModuleMember = 35653619, +>ModuleMember : SymbolFlags + + ExportHasLocal = 944, +>ExportHasLocal : SymbolFlags + + HasLocals = 1041936, +>HasLocals : SymbolFlags + + HasExports = 1952, +>HasExports : SymbolFlags + + HasMembers = 6240, +>HasMembers : SymbolFlags + + IsContainer = 1048560, +>IsContainer : SymbolFlags + + PropertyOrAccessor = 98308, +>PropertyOrAccessor : SymbolFlags + + Export = 29360128, +>Export : SymbolFlags + } + interface Symbol { +>Symbol : Symbol + + flags: SymbolFlags; +>flags : SymbolFlags +>SymbolFlags : SymbolFlags + + name: string; +>name : string + + id?: number; +>id : number + + mergeId?: number; +>mergeId : number + + declarations?: Declaration[]; +>declarations : Declaration[] +>Declaration : Declaration + + parent?: Symbol; +>parent : Symbol +>Symbol : Symbol + + members?: SymbolTable; +>members : SymbolTable +>SymbolTable : SymbolTable + + exports?: SymbolTable; +>exports : SymbolTable +>SymbolTable : SymbolTable + + exportSymbol?: Symbol; +>exportSymbol : Symbol +>Symbol : Symbol + + valueDeclaration?: Declaration; +>valueDeclaration : Declaration +>Declaration : Declaration + + constEnumOnlyModule?: boolean; +>constEnumOnlyModule : boolean + } + interface SymbolLinks { +>SymbolLinks : SymbolLinks + + target?: Symbol; +>target : Symbol +>Symbol : Symbol + + type?: Type; +>type : Type +>Type : Type + + declaredType?: Type; +>declaredType : Type +>Type : Type + + mapper?: TypeMapper; +>mapper : TypeMapper +>TypeMapper : TypeMapper + + referenced?: boolean; +>referenced : boolean + + exportAssignSymbol?: Symbol; +>exportAssignSymbol : Symbol +>Symbol : Symbol + + unionType?: UnionType; +>unionType : UnionType +>UnionType : UnionType + } + interface TransientSymbol extends Symbol, SymbolLinks { +>TransientSymbol : TransientSymbol +>Symbol : Symbol +>SymbolLinks : SymbolLinks + } + interface SymbolTable { +>SymbolTable : SymbolTable + + [index: string]: Symbol; +>index : string +>Symbol : Symbol + } + const enum NodeCheckFlags { +>NodeCheckFlags : NodeCheckFlags + + TypeChecked = 1, +>TypeChecked : NodeCheckFlags + + LexicalThis = 2, +>LexicalThis : NodeCheckFlags + + CaptureThis = 4, +>CaptureThis : NodeCheckFlags + + EmitExtends = 8, +>EmitExtends : NodeCheckFlags + + SuperInstance = 16, +>SuperInstance : NodeCheckFlags + + SuperStatic = 32, +>SuperStatic : NodeCheckFlags + + ContextChecked = 64, +>ContextChecked : NodeCheckFlags + + EnumValuesComputed = 128, +>EnumValuesComputed : NodeCheckFlags + } + interface NodeLinks { +>NodeLinks : NodeLinks + + resolvedType?: Type; +>resolvedType : Type +>Type : Type + + resolvedSignature?: Signature; +>resolvedSignature : Signature +>Signature : Signature + + resolvedSymbol?: Symbol; +>resolvedSymbol : Symbol +>Symbol : Symbol + + flags?: NodeCheckFlags; +>flags : NodeCheckFlags +>NodeCheckFlags : NodeCheckFlags + + enumMemberValue?: number; +>enumMemberValue : number + + isIllegalTypeReferenceInConstraint?: boolean; +>isIllegalTypeReferenceInConstraint : boolean + + isVisible?: boolean; +>isVisible : boolean + + localModuleName?: string; +>localModuleName : string + + assignmentChecks?: Map; +>assignmentChecks : Map +>Map : Map + } + const enum TypeFlags { +>TypeFlags : TypeFlags + + Any = 1, +>Any : TypeFlags + + String = 2, +>String : TypeFlags + + Number = 4, +>Number : TypeFlags + + Boolean = 8, +>Boolean : TypeFlags + + Void = 16, +>Void : TypeFlags + + Undefined = 32, +>Undefined : TypeFlags + + Null = 64, +>Null : TypeFlags + + Enum = 128, +>Enum : TypeFlags + + StringLiteral = 256, +>StringLiteral : TypeFlags + + TypeParameter = 512, +>TypeParameter : TypeFlags + + Class = 1024, +>Class : TypeFlags + + Interface = 2048, +>Interface : TypeFlags + + Reference = 4096, +>Reference : TypeFlags + + Tuple = 8192, +>Tuple : TypeFlags + + Union = 16384, +>Union : TypeFlags + + Anonymous = 32768, +>Anonymous : TypeFlags + + FromSignature = 65536, +>FromSignature : TypeFlags + + Intrinsic = 127, +>Intrinsic : TypeFlags + + StringLike = 258, +>StringLike : TypeFlags + + NumberLike = 132, +>NumberLike : TypeFlags + + ObjectType = 48128, +>ObjectType : TypeFlags + + Structured = 65025, +>Structured : TypeFlags + } + interface Type { +>Type : Type + + flags: TypeFlags; +>flags : TypeFlags +>TypeFlags : TypeFlags + + id: number; +>id : number + + symbol?: Symbol; +>symbol : Symbol +>Symbol : Symbol + } + interface IntrinsicType extends Type { +>IntrinsicType : IntrinsicType +>Type : Type + + intrinsicName: string; +>intrinsicName : string + } + interface StringLiteralType extends Type { +>StringLiteralType : StringLiteralType +>Type : Type + + text: string; +>text : string + } + interface ObjectType extends Type { +>ObjectType : ObjectType +>Type : Type + } + interface InterfaceType extends ObjectType { +>InterfaceType : InterfaceType +>ObjectType : ObjectType + + typeParameters: TypeParameter[]; +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter + + baseTypes: ObjectType[]; +>baseTypes : ObjectType[] +>ObjectType : ObjectType + + declaredProperties: Symbol[]; +>declaredProperties : Symbol[] +>Symbol : Symbol + + declaredCallSignatures: Signature[]; +>declaredCallSignatures : Signature[] +>Signature : Signature + + declaredConstructSignatures: Signature[]; +>declaredConstructSignatures : Signature[] +>Signature : Signature + + declaredStringIndexType: Type; +>declaredStringIndexType : Type +>Type : Type + + declaredNumberIndexType: Type; +>declaredNumberIndexType : Type +>Type : Type + } + interface TypeReference extends ObjectType { +>TypeReference : TypeReference +>ObjectType : ObjectType + + target: GenericType; +>target : GenericType +>GenericType : GenericType + + typeArguments: Type[]; +>typeArguments : Type[] +>Type : Type + } + interface GenericType extends InterfaceType, TypeReference { +>GenericType : GenericType +>InterfaceType : InterfaceType +>TypeReference : TypeReference + + instantiations: Map; +>instantiations : Map +>Map : Map +>TypeReference : TypeReference + + openReferenceTargets: GenericType[]; +>openReferenceTargets : GenericType[] +>GenericType : GenericType + + openReferenceChecks: Map; +>openReferenceChecks : Map +>Map : Map + } + interface TupleType extends ObjectType { +>TupleType : TupleType +>ObjectType : ObjectType + + elementTypes: Type[]; +>elementTypes : Type[] +>Type : Type + + baseArrayType: TypeReference; +>baseArrayType : TypeReference +>TypeReference : TypeReference + } + interface UnionType extends Type { +>UnionType : UnionType +>Type : Type + + types: Type[]; +>types : Type[] +>Type : Type + + resolvedProperties: SymbolTable; +>resolvedProperties : SymbolTable +>SymbolTable : SymbolTable + } + interface ResolvedType extends ObjectType, UnionType { +>ResolvedType : ResolvedType +>ObjectType : ObjectType +>UnionType : UnionType + + members: SymbolTable; +>members : SymbolTable +>SymbolTable : SymbolTable + + properties: Symbol[]; +>properties : Symbol[] +>Symbol : Symbol + + callSignatures: Signature[]; +>callSignatures : Signature[] +>Signature : Signature + + constructSignatures: Signature[]; +>constructSignatures : Signature[] +>Signature : Signature + + stringIndexType: Type; +>stringIndexType : Type +>Type : Type + + numberIndexType: Type; +>numberIndexType : Type +>Type : Type + } + interface TypeParameter extends Type { +>TypeParameter : TypeParameter +>Type : Type + + constraint: Type; +>constraint : Type +>Type : Type + + target?: TypeParameter; +>target : TypeParameter +>TypeParameter : TypeParameter + + mapper?: TypeMapper; +>mapper : TypeMapper +>TypeMapper : TypeMapper + } + const enum SignatureKind { +>SignatureKind : SignatureKind + + Call = 0, +>Call : SignatureKind + + Construct = 1, +>Construct : SignatureKind + } + interface Signature { +>Signature : Signature + + declaration: SignatureDeclaration; +>declaration : SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration + + typeParameters: TypeParameter[]; +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter + + parameters: Symbol[]; +>parameters : Symbol[] +>Symbol : Symbol + + resolvedReturnType: Type; +>resolvedReturnType : Type +>Type : Type + + minArgumentCount: number; +>minArgumentCount : number + + hasRestParameter: boolean; +>hasRestParameter : boolean + + hasStringLiterals: boolean; +>hasStringLiterals : boolean + + target?: Signature; +>target : Signature +>Signature : Signature + + mapper?: TypeMapper; +>mapper : TypeMapper +>TypeMapper : TypeMapper + + unionSignatures?: Signature[]; +>unionSignatures : Signature[] +>Signature : Signature + + erasedSignatureCache?: Signature; +>erasedSignatureCache : Signature +>Signature : Signature + + isolatedSignatureType?: ObjectType; +>isolatedSignatureType : ObjectType +>ObjectType : ObjectType + } + const enum IndexKind { +>IndexKind : IndexKind + + String = 0, +>String : IndexKind + + Number = 1, +>Number : IndexKind + } + interface TypeMapper { +>TypeMapper : TypeMapper + + (t: Type): Type; +>t : Type +>Type : Type +>Type : Type + } + interface TypeInferences { +>TypeInferences : TypeInferences + + primary: Type[]; +>primary : Type[] +>Type : Type + + secondary: Type[]; +>secondary : Type[] +>Type : Type + } + interface InferenceContext { +>InferenceContext : InferenceContext + + typeParameters: TypeParameter[]; +>typeParameters : TypeParameter[] +>TypeParameter : TypeParameter + + inferUnionTypes: boolean; +>inferUnionTypes : boolean + + inferences: TypeInferences[]; +>inferences : TypeInferences[] +>TypeInferences : TypeInferences + + inferredTypes: Type[]; +>inferredTypes : Type[] +>Type : Type + + failedTypeParameterIndex?: number; +>failedTypeParameterIndex : number + } + interface DiagnosticMessage { +>DiagnosticMessage : DiagnosticMessage + + key: string; +>key : string + + category: DiagnosticCategory; +>category : DiagnosticCategory +>DiagnosticCategory : DiagnosticCategory + + code: number; +>code : number + + isEarly?: boolean; +>isEarly : boolean + } + interface DiagnosticMessageChain { +>DiagnosticMessageChain : DiagnosticMessageChain + + messageText: string; +>messageText : string + + category: DiagnosticCategory; +>category : DiagnosticCategory +>DiagnosticCategory : DiagnosticCategory + + code: number; +>code : number + + next?: DiagnosticMessageChain; +>next : DiagnosticMessageChain +>DiagnosticMessageChain : DiagnosticMessageChain + } + interface Diagnostic { +>Diagnostic : Diagnostic + + file: SourceFile; +>file : SourceFile +>SourceFile : SourceFile + + start: number; +>start : number + + length: number; +>length : number + + messageText: string; +>messageText : string + + category: DiagnosticCategory; +>category : DiagnosticCategory +>DiagnosticCategory : DiagnosticCategory + + code: number; +>code : number + + /** + * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit + */ + isEarly?: boolean; +>isEarly : boolean + + /** + * Parse error - error produced by parser when it scanner returns a token + * that parser does not understand in its current state + * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) + */ + isParseError?: boolean; +>isParseError : boolean + } + enum DiagnosticCategory { +>DiagnosticCategory : DiagnosticCategory + + Warning = 0, +>Warning : DiagnosticCategory + + Error = 1, +>Error : DiagnosticCategory + + Message = 2, +>Message : DiagnosticCategory + } + interface CompilerOptions { +>CompilerOptions : CompilerOptions + + charset?: string; +>charset : string + + codepage?: number; +>codepage : number + + declaration?: boolean; +>declaration : boolean + + diagnostics?: boolean; +>diagnostics : boolean + + emitBOM?: boolean; +>emitBOM : boolean + + help?: boolean; +>help : boolean + + locale?: string; +>locale : string + + mapRoot?: string; +>mapRoot : string + + module?: ModuleKind; +>module : ModuleKind +>ModuleKind : ModuleKind + + noEmitOnError?: boolean; +>noEmitOnError : boolean + + noErrorTruncation?: boolean; +>noErrorTruncation : boolean + + noImplicitAny?: boolean; +>noImplicitAny : boolean + + noLib?: boolean; +>noLib : boolean + + noLibCheck?: boolean; +>noLibCheck : boolean + + noResolve?: boolean; +>noResolve : boolean + + out?: string; +>out : string + + outDir?: string; +>outDir : string + + removeComments?: boolean; +>removeComments : boolean + + sourceMap?: boolean; +>sourceMap : boolean + + sourceRoot?: string; +>sourceRoot : string + + target?: ScriptTarget; +>target : ScriptTarget +>ScriptTarget : ScriptTarget + + version?: boolean; +>version : boolean + + watch?: boolean; +>watch : boolean + + preserveConstEnums?: boolean; +>preserveConstEnums : boolean + + [option: string]: string | number | boolean; +>option : string + } + const enum ModuleKind { +>ModuleKind : ModuleKind + + None = 0, +>None : ModuleKind + + CommonJS = 1, +>CommonJS : ModuleKind + + AMD = 2, +>AMD : ModuleKind + } + interface LineAndCharacter { +>LineAndCharacter : LineAndCharacter + + line: number; +>line : number + + character: number; +>character : number + } + const enum ScriptTarget { +>ScriptTarget : ScriptTarget + + ES3 = 0, +>ES3 : ScriptTarget + + ES5 = 1, +>ES5 : ScriptTarget + + ES6 = 2, +>ES6 : ScriptTarget + + Latest = 2, +>Latest : ScriptTarget + } + interface ParsedCommandLine { +>ParsedCommandLine : ParsedCommandLine + + options: CompilerOptions; +>options : CompilerOptions +>CompilerOptions : CompilerOptions + + filenames: string[]; +>filenames : string[] + + errors: Diagnostic[]; +>errors : Diagnostic[] +>Diagnostic : Diagnostic + } + interface CommandLineOption { +>CommandLineOption : CommandLineOption + + name: string; +>name : string + + type: string | Map; +>type : string | Map +>Map : Map + + shortName?: string; +>shortName : string + + description?: DiagnosticMessage; +>description : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + + paramName?: DiagnosticMessage; +>paramName : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + + error?: DiagnosticMessage; +>error : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + } + const enum CharacterCodes { +>CharacterCodes : CharacterCodes + + nullCharacter = 0, +>nullCharacter : CharacterCodes + + maxAsciiCharacter = 127, +>maxAsciiCharacter : CharacterCodes + + lineFeed = 10, +>lineFeed : CharacterCodes + + carriageReturn = 13, +>carriageReturn : CharacterCodes + + lineSeparator = 8232, +>lineSeparator : CharacterCodes + + paragraphSeparator = 8233, +>paragraphSeparator : CharacterCodes + + nextLine = 133, +>nextLine : CharacterCodes + + space = 32, +>space : CharacterCodes + + nonBreakingSpace = 160, +>nonBreakingSpace : CharacterCodes + + enQuad = 8192, +>enQuad : CharacterCodes + + emQuad = 8193, +>emQuad : CharacterCodes + + enSpace = 8194, +>enSpace : CharacterCodes + + emSpace = 8195, +>emSpace : CharacterCodes + + threePerEmSpace = 8196, +>threePerEmSpace : CharacterCodes + + fourPerEmSpace = 8197, +>fourPerEmSpace : CharacterCodes + + sixPerEmSpace = 8198, +>sixPerEmSpace : CharacterCodes + + figureSpace = 8199, +>figureSpace : CharacterCodes + + punctuationSpace = 8200, +>punctuationSpace : CharacterCodes + + thinSpace = 8201, +>thinSpace : CharacterCodes + + hairSpace = 8202, +>hairSpace : CharacterCodes + + zeroWidthSpace = 8203, +>zeroWidthSpace : CharacterCodes + + narrowNoBreakSpace = 8239, +>narrowNoBreakSpace : CharacterCodes + + ideographicSpace = 12288, +>ideographicSpace : CharacterCodes + + mathematicalSpace = 8287, +>mathematicalSpace : CharacterCodes + + ogham = 5760, +>ogham : CharacterCodes + + _ = 95, +>_ : CharacterCodes + + $ = 36, +>$ : CharacterCodes + + _0 = 48, +>_0 : CharacterCodes + + _1 = 49, +>_1 : CharacterCodes + + _2 = 50, +>_2 : CharacterCodes + + _3 = 51, +>_3 : CharacterCodes + + _4 = 52, +>_4 : CharacterCodes + + _5 = 53, +>_5 : CharacterCodes + + _6 = 54, +>_6 : CharacterCodes + + _7 = 55, +>_7 : CharacterCodes + + _8 = 56, +>_8 : CharacterCodes + + _9 = 57, +>_9 : CharacterCodes + + a = 97, +>a : CharacterCodes + + b = 98, +>b : CharacterCodes + + c = 99, +>c : CharacterCodes + + d = 100, +>d : CharacterCodes + + e = 101, +>e : CharacterCodes + + f = 102, +>f : CharacterCodes + + g = 103, +>g : CharacterCodes + + h = 104, +>h : CharacterCodes + + i = 105, +>i : CharacterCodes + + j = 106, +>j : CharacterCodes + + k = 107, +>k : CharacterCodes + + l = 108, +>l : CharacterCodes + + m = 109, +>m : CharacterCodes + + n = 110, +>n : CharacterCodes + + o = 111, +>o : CharacterCodes + + p = 112, +>p : CharacterCodes + + q = 113, +>q : CharacterCodes + + r = 114, +>r : CharacterCodes + + s = 115, +>s : CharacterCodes + + t = 116, +>t : CharacterCodes + + u = 117, +>u : CharacterCodes + + v = 118, +>v : CharacterCodes + + w = 119, +>w : CharacterCodes + + x = 120, +>x : CharacterCodes + + y = 121, +>y : CharacterCodes + + z = 122, +>z : CharacterCodes + + A = 65, +>A : CharacterCodes + + B = 66, +>B : CharacterCodes + + C = 67, +>C : CharacterCodes + + D = 68, +>D : CharacterCodes + + E = 69, +>E : CharacterCodes + + F = 70, +>F : CharacterCodes + + G = 71, +>G : CharacterCodes + + H = 72, +>H : CharacterCodes + + I = 73, +>I : CharacterCodes + + J = 74, +>J : CharacterCodes + + K = 75, +>K : CharacterCodes + + L = 76, +>L : CharacterCodes + + M = 77, +>M : CharacterCodes + + N = 78, +>N : CharacterCodes + + O = 79, +>O : CharacterCodes + + P = 80, +>P : CharacterCodes + + Q = 81, +>Q : CharacterCodes + + R = 82, +>R : CharacterCodes + + S = 83, +>S : CharacterCodes + + T = 84, +>T : CharacterCodes + + U = 85, +>U : CharacterCodes + + V = 86, +>V : CharacterCodes + + W = 87, +>W : CharacterCodes + + X = 88, +>X : CharacterCodes + + Y = 89, +>Y : CharacterCodes + + Z = 90, +>Z : CharacterCodes + + ampersand = 38, +>ampersand : CharacterCodes + + asterisk = 42, +>asterisk : CharacterCodes + + at = 64, +>at : CharacterCodes + + backslash = 92, +>backslash : CharacterCodes + + backtick = 96, +>backtick : CharacterCodes + + bar = 124, +>bar : CharacterCodes + + caret = 94, +>caret : CharacterCodes + + closeBrace = 125, +>closeBrace : CharacterCodes + + closeBracket = 93, +>closeBracket : CharacterCodes + + closeParen = 41, +>closeParen : CharacterCodes + + colon = 58, +>colon : CharacterCodes + + comma = 44, +>comma : CharacterCodes + + dot = 46, +>dot : CharacterCodes + + doubleQuote = 34, +>doubleQuote : CharacterCodes + + equals = 61, +>equals : CharacterCodes + + exclamation = 33, +>exclamation : CharacterCodes + + greaterThan = 62, +>greaterThan : CharacterCodes + + lessThan = 60, +>lessThan : CharacterCodes + + minus = 45, +>minus : CharacterCodes + + openBrace = 123, +>openBrace : CharacterCodes + + openBracket = 91, +>openBracket : CharacterCodes + + openParen = 40, +>openParen : CharacterCodes + + percent = 37, +>percent : CharacterCodes + + plus = 43, +>plus : CharacterCodes + + question = 63, +>question : CharacterCodes + + semicolon = 59, +>semicolon : CharacterCodes + + singleQuote = 39, +>singleQuote : CharacterCodes + + slash = 47, +>slash : CharacterCodes + + tilde = 126, +>tilde : CharacterCodes + + backspace = 8, +>backspace : CharacterCodes + + formFeed = 12, +>formFeed : CharacterCodes + + byteOrderMark = 65279, +>byteOrderMark : CharacterCodes + + tab = 9, +>tab : CharacterCodes + + verticalTab = 11, +>verticalTab : CharacterCodes + } + interface CancellationToken { +>CancellationToken : CancellationToken + + isCancellationRequested(): boolean; +>isCancellationRequested : () => boolean + } + interface CompilerHost { +>CompilerHost : CompilerHost + + getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; +>getSourceFile : (filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void) => SourceFile +>filename : string +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget +>onError : (message: string) => void +>message : string +>SourceFile : SourceFile + + getDefaultLibFilename(): string; +>getDefaultLibFilename : () => string + + getCancellationToken?(): CancellationToken; +>getCancellationToken : () => CancellationToken +>CancellationToken : CancellationToken + + writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; +>writeFile : (filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) => void +>filename : string +>data : string +>writeByteOrderMark : boolean +>onError : (message: string) => void +>message : string + + getCurrentDirectory(): string; +>getCurrentDirectory : () => string + + getCanonicalFileName(fileName: string): string; +>getCanonicalFileName : (fileName: string) => string +>fileName : string + + useCaseSensitiveFileNames(): boolean; +>useCaseSensitiveFileNames : () => boolean + + getNewLine(): string; +>getNewLine : () => string + } +} +declare module ts { +>ts : typeof ts + + interface ErrorCallback { +>ErrorCallback : ErrorCallback + + (message: DiagnosticMessage): void; +>message : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + } + interface CommentCallback { +>CommentCallback : CommentCallback + + (pos: number, end: number): void; +>pos : number +>end : number + } + interface Scanner { +>Scanner : Scanner + + getStartPos(): number; +>getStartPos : () => number + + getToken(): SyntaxKind; +>getToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + getTextPos(): number; +>getTextPos : () => number + + getTokenPos(): number; +>getTokenPos : () => number + + getTokenText(): string; +>getTokenText : () => string + + getTokenValue(): string; +>getTokenValue : () => string + + hasPrecedingLineBreak(): boolean; +>hasPrecedingLineBreak : () => boolean + + isIdentifier(): boolean; +>isIdentifier : () => boolean + + isReservedWord(): boolean; +>isReservedWord : () => boolean + + reScanGreaterToken(): SyntaxKind; +>reScanGreaterToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + reScanSlashToken(): SyntaxKind; +>reScanSlashToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + reScanTemplateToken(): SyntaxKind; +>reScanTemplateToken : () => SyntaxKind +>SyntaxKind : SyntaxKind + + scan(): SyntaxKind; +>scan : () => SyntaxKind +>SyntaxKind : SyntaxKind + + setText(text: string): void; +>setText : (text: string) => void +>text : string + + setTextPos(textPos: number): void; +>setTextPos : (textPos: number) => void +>textPos : number + + tryScan(callback: () => T): T; +>tryScan : (callback: () => T) => T +>T : T +>callback : () => T +>T : T +>T : T + } + function tokenToString(t: SyntaxKind): string; +>tokenToString : (t: SyntaxKind) => string +>t : SyntaxKind +>SyntaxKind : SyntaxKind + + function computeLineStarts(text: string): number[]; +>computeLineStarts : (text: string) => number[] +>text : string + + function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number; +>getPositionFromLineAndCharacter : (lineStarts: number[], line: number, character: number) => number +>lineStarts : number[] +>line : number +>character : number + + function getLineAndCharacterOfPosition(lineStarts: number[], position: number): { +>getLineAndCharacterOfPosition : (lineStarts: number[], position: number) => { line: number; character: number; } +>lineStarts : number[] +>position : number + + line: number; +>line : number + + character: number; +>character : number + + }; + function positionToLineAndCharacter(text: string, pos: number): { +>positionToLineAndCharacter : (text: string, pos: number) => { line: number; character: number; } +>text : string +>pos : number + + line: number; +>line : number + + character: number; +>character : number + + }; + function isWhiteSpace(ch: number): boolean; +>isWhiteSpace : (ch: number) => boolean +>ch : number + + function isLineBreak(ch: number): boolean; +>isLineBreak : (ch: number) => boolean +>ch : number + + function isOctalDigit(ch: number): boolean; +>isOctalDigit : (ch: number) => boolean +>ch : number + + function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number; +>skipTrivia : (text: string, pos: number, stopAfterLineBreak?: boolean) => number +>text : string +>pos : number +>stopAfterLineBreak : boolean + + function getLeadingCommentRanges(text: string, pos: number): CommentRange[]; +>getLeadingCommentRanges : (text: string, pos: number) => CommentRange[] +>text : string +>pos : number +>CommentRange : CommentRange + + function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; +>getTrailingCommentRanges : (text: string, pos: number) => CommentRange[] +>text : string +>pos : number +>CommentRange : CommentRange + + function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; +>isIdentifierStart : (ch: number, languageVersion: ScriptTarget) => boolean +>ch : number +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget + + function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; +>isIdentifierPart : (ch: number, languageVersion: ScriptTarget) => boolean +>ch : number +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget + + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; +>createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback) => Scanner +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget +>skipTrivia : boolean +>text : string +>onError : ErrorCallback +>ErrorCallback : ErrorCallback +>onComment : CommentCallback +>CommentCallback : CommentCallback +>Scanner : Scanner +} +declare module ts { +>ts : typeof ts + + interface ReferencePathMatchResult { +>ReferencePathMatchResult : ReferencePathMatchResult + + fileReference?: FileReference; +>fileReference : FileReference +>FileReference : FileReference + + diagnostic?: DiagnosticMessage; +>diagnostic : DiagnosticMessage +>DiagnosticMessage : DiagnosticMessage + + isNoDefaultLib?: boolean; +>isNoDefaultLib : boolean + } + function getNodeConstructor(kind: SyntaxKind): new () => Node; +>getNodeConstructor : (kind: SyntaxKind) => new () => Node +>kind : SyntaxKind +>SyntaxKind : SyntaxKind +>Node : Node + + function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; +>forEachChild : (node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T) => T +>T : T +>node : Node +>Node : Node +>cbNode : (node: Node) => T +>node : Node +>Node : Node +>T : T +>cbNodes : (nodes: Node[]) => T +>nodes : Node[] +>Node : Node +>T : T +>T : T + + function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; +>createSourceFile : (filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean) => SourceFile +>filename : string +>sourceText : string +>languageVersion : ScriptTarget +>ScriptTarget : ScriptTarget +>version : string +>isOpen : boolean +>SourceFile : SourceFile + + function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program; +>createProgram : (rootNames: string[], options: CompilerOptions, host: CompilerHost) => Program +>rootNames : string[] +>options : CompilerOptions +>CompilerOptions : CompilerOptions +>host : CompilerHost +>CompilerHost : CompilerHost +>Program : Program +} +declare module ts { +>ts : typeof ts + + function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker; +>createTypeChecker : (program: Program, fullTypeCheck: boolean) => TypeChecker +>program : Program +>Program : Program +>fullTypeCheck : boolean +>TypeChecker : TypeChecker +} +declare module ts { +>ts : typeof ts + + interface Node { +>Node : Node + + getSourceFile(): SourceFile; +>getSourceFile : () => SourceFile +>SourceFile : SourceFile + + getChildCount(sourceFile?: SourceFile): number; +>getChildCount : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getChildAt(index: number, sourceFile?: SourceFile): Node; +>getChildAt : (index: number, sourceFile?: SourceFile) => Node +>index : number +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + + getChildren(sourceFile?: SourceFile): Node[]; +>getChildren : (sourceFile?: SourceFile) => Node[] +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + + getStart(sourceFile?: SourceFile): number; +>getStart : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFullStart(): number; +>getFullStart : () => number + + getEnd(): number; +>getEnd : () => number + + getWidth(sourceFile?: SourceFile): number; +>getWidth : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFullWidth(): number; +>getFullWidth : () => number + + getLeadingTriviaWidth(sourceFile?: SourceFile): number; +>getLeadingTriviaWidth : (sourceFile?: SourceFile) => number +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFullText(sourceFile?: SourceFile): string; +>getFullText : (sourceFile?: SourceFile) => string +>sourceFile : SourceFile +>SourceFile : SourceFile + + getText(sourceFile?: SourceFile): string; +>getText : (sourceFile?: SourceFile) => string +>sourceFile : SourceFile +>SourceFile : SourceFile + + getFirstToken(sourceFile?: SourceFile): Node; +>getFirstToken : (sourceFile?: SourceFile) => Node +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + + getLastToken(sourceFile?: SourceFile): Node; +>getLastToken : (sourceFile?: SourceFile) => Node +>sourceFile : SourceFile +>SourceFile : SourceFile +>Node : Node + } + interface Symbol { +>Symbol : Symbol + + getFlags(): SymbolFlags; +>getFlags : () => SymbolFlags +>SymbolFlags : SymbolFlags + + getName(): string; +>getName : () => string + + getDeclarations(): Declaration[]; +>getDeclarations : () => Declaration[] +>Declaration : Declaration + + getDocumentationComment(): SymbolDisplayPart[]; +>getDocumentationComment : () => SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface Type { +>Type : Type + + getFlags(): TypeFlags; +>getFlags : () => TypeFlags +>TypeFlags : TypeFlags + + getSymbol(): Symbol; +>getSymbol : () => Symbol +>Symbol : Symbol + + getProperties(): Symbol[]; +>getProperties : () => Symbol[] +>Symbol : Symbol + + getProperty(propertyName: string): Symbol; +>getProperty : (propertyName: string) => Symbol +>propertyName : string +>Symbol : Symbol + + getApparentProperties(): Symbol[]; +>getApparentProperties : () => Symbol[] +>Symbol : Symbol + + getCallSignatures(): Signature[]; +>getCallSignatures : () => Signature[] +>Signature : Signature + + getConstructSignatures(): Signature[]; +>getConstructSignatures : () => Signature[] +>Signature : Signature + + getStringIndexType(): Type; +>getStringIndexType : () => Type +>Type : Type + + getNumberIndexType(): Type; +>getNumberIndexType : () => Type +>Type : Type + } + interface Signature { +>Signature : Signature + + getDeclaration(): SignatureDeclaration; +>getDeclaration : () => SignatureDeclaration +>SignatureDeclaration : SignatureDeclaration + + getTypeParameters(): Type[]; +>getTypeParameters : () => Type[] +>Type : Type + + getParameters(): Symbol[]; +>getParameters : () => Symbol[] +>Symbol : Symbol + + getReturnType(): Type; +>getReturnType : () => Type +>Type : Type + + getDocumentationComment(): SymbolDisplayPart[]; +>getDocumentationComment : () => SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface SourceFile { +>SourceFile : SourceFile + + getScriptSnapshot(): IScriptSnapshot; +>getScriptSnapshot : () => IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot + + getNamedDeclarations(): Declaration[]; +>getNamedDeclarations : () => Declaration[] +>Declaration : Declaration + + update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; +>update : (scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile +>scriptSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>version : string +>isOpen : boolean +>textChangeRange : TextChangeRange +>TextChangeRange : TextChangeRange +>SourceFile : SourceFile + } + /** + * Represents an immutable snapshot of a script at a specified time.Once acquired, the + * snapshot is observably immutable. i.e. the same calls with the same parameters will return + * the same values. + */ + interface IScriptSnapshot { +>IScriptSnapshot : IScriptSnapshot + + /** Gets a portion of the script snapshot specified by [start, end). */ + getText(start: number, end: number): string; +>getText : (start: number, end: number) => string +>start : number +>end : number + + /** Gets the length of this script snapshot. */ + getLength(): number; +>getLength : () => number + + /** + * This call returns the array containing the start position of every line. + * i.e."[0, 10, 55]". TODO: consider making this optional. The language service could + * always determine this (albeit in a more expensive manner). + */ + getLineStartPositions(): number[]; +>getLineStartPositions : () => number[] + + /** + * Gets the TextChangeRange that describe how the text changed between this text and + * an older version. This information is used by the incremental parser to determine + * what sections of the script need to be re-parsed. 'undefined' can be returned if the + * change range cannot be determined. However, in that case, incremental parsing will + * not happen and the entire document will be re - parsed. + */ + getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange; +>getChangeRange : (oldSnapshot: IScriptSnapshot) => TextChangeRange +>oldSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>TextChangeRange : TextChangeRange + } + module ScriptSnapshot { +>ScriptSnapshot : typeof ScriptSnapshot + + function fromString(text: string): IScriptSnapshot; +>fromString : (text: string) => IScriptSnapshot +>text : string +>IScriptSnapshot : IScriptSnapshot + } + interface PreProcessedFileInfo { +>PreProcessedFileInfo : PreProcessedFileInfo + + referencedFiles: FileReference[]; +>referencedFiles : FileReference[] +>FileReference : FileReference + + importedFiles: FileReference[]; +>importedFiles : FileReference[] +>FileReference : FileReference + + isLibFile: boolean; +>isLibFile : boolean + } + interface Logger { +>Logger : Logger + + log(s: string): void; +>log : (s: string) => void +>s : string + } + interface LanguageServiceHost extends Logger { +>LanguageServiceHost : LanguageServiceHost +>Logger : Logger + + getCompilationSettings(): CompilerOptions; +>getCompilationSettings : () => CompilerOptions +>CompilerOptions : CompilerOptions + + getScriptFileNames(): string[]; +>getScriptFileNames : () => string[] + + getScriptVersion(fileName: string): string; +>getScriptVersion : (fileName: string) => string +>fileName : string + + getScriptIsOpen(fileName: string): boolean; +>getScriptIsOpen : (fileName: string) => boolean +>fileName : string + + getScriptSnapshot(fileName: string): IScriptSnapshot; +>getScriptSnapshot : (fileName: string) => IScriptSnapshot +>fileName : string +>IScriptSnapshot : IScriptSnapshot + + getLocalizedDiagnosticMessages(): any; +>getLocalizedDiagnosticMessages : () => any + + getCancellationToken(): CancellationToken; +>getCancellationToken : () => CancellationToken +>CancellationToken : CancellationToken + + getCurrentDirectory(): string; +>getCurrentDirectory : () => string + + getDefaultLibFilename(): string; +>getDefaultLibFilename : () => string + } + interface LanguageService { +>LanguageService : LanguageService + + cleanupSemanticCache(): void; +>cleanupSemanticCache : () => void + + getSyntacticDiagnostics(fileName: string): Diagnostic[]; +>getSyntacticDiagnostics : (fileName: string) => Diagnostic[] +>fileName : string +>Diagnostic : Diagnostic + + getSemanticDiagnostics(fileName: string): Diagnostic[]; +>getSemanticDiagnostics : (fileName: string) => Diagnostic[] +>fileName : string +>Diagnostic : Diagnostic + + getCompilerOptionsDiagnostics(): Diagnostic[]; +>getCompilerOptionsDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; +>getSyntacticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[] +>fileName : string +>span : TextSpan +>TextSpan : TextSpan +>ClassifiedSpan : ClassifiedSpan + + getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; +>getSemanticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[] +>fileName : string +>span : TextSpan +>TextSpan : TextSpan +>ClassifiedSpan : ClassifiedSpan + + getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; +>getCompletionsAtPosition : (fileName: string, position: number, isMemberCompletion: boolean) => CompletionInfo +>fileName : string +>position : number +>isMemberCompletion : boolean +>CompletionInfo : CompletionInfo + + getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; +>getCompletionEntryDetails : (fileName: string, position: number, entryName: string) => CompletionEntryDetails +>fileName : string +>position : number +>entryName : string +>CompletionEntryDetails : CompletionEntryDetails + + getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; +>getQuickInfoAtPosition : (fileName: string, position: number) => QuickInfo +>fileName : string +>position : number +>QuickInfo : QuickInfo + + getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan; +>getNameOrDottedNameSpan : (fileName: string, startPos: number, endPos: number) => TextSpan +>fileName : string +>startPos : number +>endPos : number +>TextSpan : TextSpan + + getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan; +>getBreakpointStatementAtPosition : (fileName: string, position: number) => TextSpan +>fileName : string +>position : number +>TextSpan : TextSpan + + getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems; +>getSignatureHelpItems : (fileName: string, position: number) => SignatureHelpItems +>fileName : string +>position : number +>SignatureHelpItems : SignatureHelpItems + + getRenameInfo(fileName: string, position: number): RenameInfo; +>getRenameInfo : (fileName: string, position: number) => RenameInfo +>fileName : string +>position : number +>RenameInfo : RenameInfo + + findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[]; +>findRenameLocations : (fileName: string, position: number, findInStrings: boolean, findInComments: boolean) => RenameLocation[] +>fileName : string +>position : number +>findInStrings : boolean +>findInComments : boolean +>RenameLocation : RenameLocation + + getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[]; +>getDefinitionAtPosition : (fileName: string, position: number) => DefinitionInfo[] +>fileName : string +>position : number +>DefinitionInfo : DefinitionInfo + + getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[]; +>getReferencesAtPosition : (fileName: string, position: number) => ReferenceEntry[] +>fileName : string +>position : number +>ReferenceEntry : ReferenceEntry + + getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[]; +>getOccurrencesAtPosition : (fileName: string, position: number) => ReferenceEntry[] +>fileName : string +>position : number +>ReferenceEntry : ReferenceEntry + + getNavigateToItems(searchValue: string): NavigateToItem[]; +>getNavigateToItems : (searchValue: string) => NavigateToItem[] +>searchValue : string +>NavigateToItem : NavigateToItem + + getNavigationBarItems(fileName: string): NavigationBarItem[]; +>getNavigationBarItems : (fileName: string) => NavigationBarItem[] +>fileName : string +>NavigationBarItem : NavigationBarItem + + getOutliningSpans(fileName: string): OutliningSpan[]; +>getOutliningSpans : (fileName: string) => OutliningSpan[] +>fileName : string +>OutliningSpan : OutliningSpan + + getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[]; +>getTodoComments : (fileName: string, descriptors: TodoCommentDescriptor[]) => TodoComment[] +>fileName : string +>descriptors : TodoCommentDescriptor[] +>TodoCommentDescriptor : TodoCommentDescriptor +>TodoComment : TodoComment + + getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[]; +>getBraceMatchingAtPosition : (fileName: string, position: number) => TextSpan[] +>fileName : string +>position : number +>TextSpan : TextSpan + + getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number; +>getIndentationAtPosition : (fileName: string, position: number, options: EditorOptions) => number +>fileName : string +>position : number +>options : EditorOptions +>EditorOptions : EditorOptions + + getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[]; +>getFormattingEditsForRange : (fileName: string, start: number, end: number, options: FormatCodeOptions) => TextChange[] +>fileName : string +>start : number +>end : number +>options : FormatCodeOptions +>FormatCodeOptions : FormatCodeOptions +>TextChange : TextChange + + getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[]; +>getFormattingEditsForDocument : (fileName: string, options: FormatCodeOptions) => TextChange[] +>fileName : string +>options : FormatCodeOptions +>FormatCodeOptions : FormatCodeOptions +>TextChange : TextChange + + getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[]; +>getFormattingEditsAfterKeystroke : (fileName: string, position: number, key: string, options: FormatCodeOptions) => TextChange[] +>fileName : string +>position : number +>key : string +>options : FormatCodeOptions +>FormatCodeOptions : FormatCodeOptions +>TextChange : TextChange + + getEmitOutput(fileName: string): EmitOutput; +>getEmitOutput : (fileName: string) => EmitOutput +>fileName : string +>EmitOutput : EmitOutput + + getSourceFile(filename: string): SourceFile; +>getSourceFile : (filename: string) => SourceFile +>filename : string +>SourceFile : SourceFile + + dispose(): void; +>dispose : () => void + } + class TextSpan { +>TextSpan : TextSpan + + private _start; +>_start : any + + private _length; +>_length : any + + /** + * Creates a TextSpan instance beginning with the position Start and having the Length + * specified with length. + */ + constructor(start: number, length: number); +>start : number +>length : number + + toJSON(key: any): any; +>toJSON : (key: any) => any +>key : any + + start(): number; +>start : () => number + + length(): number; +>length : () => number + + end(): number; +>end : () => number + + isEmpty(): boolean; +>isEmpty : () => boolean + + /** + * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less + * than End, otherwise false. + * @param position The position to check. + */ + containsPosition(position: number): boolean; +>containsPosition : (position: number) => boolean +>position : number + + /** + * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false. + * @param span The span to check. + */ + containsTextSpan(span: TextSpan): boolean; +>containsTextSpan : (span: TextSpan) => boolean +>span : TextSpan +>TextSpan : TextSpan + + /** + * Determines whether the given span overlaps this span. Two spans are considered to overlap + * if they have positions in common and neither is empty. Empty spans do not overlap with any + * other span. Returns true if the spans overlap, false otherwise. + * @param span The span to check. + */ + overlapsWith(span: TextSpan): boolean; +>overlapsWith : (span: TextSpan) => boolean +>span : TextSpan +>TextSpan : TextSpan + + /** + * Returns the overlap with the given span, or undefined if there is no overlap. + * @param span The span to check. + */ + overlap(span: TextSpan): TextSpan; +>overlap : (span: TextSpan) => TextSpan +>span : TextSpan +>TextSpan : TextSpan +>TextSpan : TextSpan + + /** + * Determines whether span intersects this span. Two spans are considered to + * intersect if they have positions in common or the end of one span + * coincides with the start of the other span. Returns true if the spans intersect, false otherwise. + * @param The span to check. + */ + intersectsWithTextSpan(span: TextSpan): boolean; +>intersectsWithTextSpan : (span: TextSpan) => boolean +>span : TextSpan +>TextSpan : TextSpan + + intersectsWith(start: number, length: number): boolean; +>intersectsWith : (start: number, length: number) => boolean +>start : number +>length : number + + /** + * Determines whether the given position intersects this span. + * A position is considered to intersect if it is between the start and + * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise. + * @param position The position to check. + */ + intersectsWithPosition(position: number): boolean; +>intersectsWithPosition : (position: number) => boolean +>position : number + + /** + * Returns the intersection with the given span, or undefined if there is no intersection. + * @param span The span to check. + */ + intersection(span: TextSpan): TextSpan; +>intersection : (span: TextSpan) => TextSpan +>span : TextSpan +>TextSpan : TextSpan +>TextSpan : TextSpan + + /** + * Creates a new TextSpan from the given start and end positions + * as opposed to a position and length. + */ + static fromBounds(start: number, end: number): TextSpan; +>fromBounds : (start: number, end: number) => TextSpan +>start : number +>end : number +>TextSpan : TextSpan + } + class TextChangeRange { +>TextChangeRange : TextChangeRange + + static unchanged: TextChangeRange; +>unchanged : TextChangeRange +>TextChangeRange : TextChangeRange + + private _span; +>_span : any + + private _newLength; +>_newLength : any + + /** + * Initializes a new instance of TextChangeRange. + */ + constructor(span: TextSpan, newLength: number); +>span : TextSpan +>TextSpan : TextSpan +>newLength : number + + /** + * The span of text before the edit which is being changed + */ + span(): TextSpan; +>span : () => TextSpan +>TextSpan : TextSpan + + /** + * Width of the span after the edit. A 0 here would represent a delete + */ + newLength(): number; +>newLength : () => number + + newSpan(): TextSpan; +>newSpan : () => TextSpan +>TextSpan : TextSpan + + isUnchanged(): boolean; +>isUnchanged : () => boolean + + /** + * Called to merge all the changes that occurred across several versions of a script snapshot + * into a single change. i.e. if a user keeps making successive edits to a script we will + * have a text change from V1 to V2, V2 to V3, ..., Vn. + * + * This function will then merge those changes into a single change range valid between V1 and + * Vn. + */ + static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; +>collapseChangesAcrossMultipleVersions : (changes: TextChangeRange[]) => TextChangeRange +>changes : TextChangeRange[] +>TextChangeRange : TextChangeRange +>TextChangeRange : TextChangeRange + } + interface ClassifiedSpan { +>ClassifiedSpan : ClassifiedSpan + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + classificationType: string; +>classificationType : string + } + interface NavigationBarItem { +>NavigationBarItem : NavigationBarItem + + text: string; +>text : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + spans: TextSpan[]; +>spans : TextSpan[] +>TextSpan : TextSpan + + childItems: NavigationBarItem[]; +>childItems : NavigationBarItem[] +>NavigationBarItem : NavigationBarItem + + indent: number; +>indent : number + + bolded: boolean; +>bolded : boolean + + grayed: boolean; +>grayed : boolean + } + interface TodoCommentDescriptor { +>TodoCommentDescriptor : TodoCommentDescriptor + + text: string; +>text : string + + priority: number; +>priority : number + } + interface TodoComment { +>TodoComment : TodoComment + + descriptor: TodoCommentDescriptor; +>descriptor : TodoCommentDescriptor +>TodoCommentDescriptor : TodoCommentDescriptor + + message: string; +>message : string + + position: number; +>position : number + } + class TextChange { +>TextChange : TextChange + + span: TextSpan; +>span : TextSpan +>TextSpan : TextSpan + + newText: string; +>newText : string + } + interface RenameLocation { +>RenameLocation : RenameLocation + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + fileName: string; +>fileName : string + } + interface ReferenceEntry { +>ReferenceEntry : ReferenceEntry + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + fileName: string; +>fileName : string + + isWriteAccess: boolean; +>isWriteAccess : boolean + } + interface NavigateToItem { +>NavigateToItem : NavigateToItem + + name: string; +>name : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + matchKind: string; +>matchKind : string + + fileName: string; +>fileName : string + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + containerName: string; +>containerName : string + + containerKind: string; +>containerKind : string + } + interface EditorOptions { +>EditorOptions : EditorOptions + + IndentSize: number; +>IndentSize : number + + TabSize: number; +>TabSize : number + + NewLineCharacter: string; +>NewLineCharacter : string + + ConvertTabsToSpaces: boolean; +>ConvertTabsToSpaces : boolean + } + interface FormatCodeOptions extends EditorOptions { +>FormatCodeOptions : FormatCodeOptions +>EditorOptions : EditorOptions + + InsertSpaceAfterCommaDelimiter: boolean; +>InsertSpaceAfterCommaDelimiter : boolean + + InsertSpaceAfterSemicolonInForStatements: boolean; +>InsertSpaceAfterSemicolonInForStatements : boolean + + InsertSpaceBeforeAndAfterBinaryOperators: boolean; +>InsertSpaceBeforeAndAfterBinaryOperators : boolean + + InsertSpaceAfterKeywordsInControlFlowStatements: boolean; +>InsertSpaceAfterKeywordsInControlFlowStatements : boolean + + InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean; +>InsertSpaceAfterFunctionKeywordForAnonymousFunctions : boolean + + InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean; +>InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis : boolean + + PlaceOpenBraceOnNewLineForFunctions: boolean; +>PlaceOpenBraceOnNewLineForFunctions : boolean + + PlaceOpenBraceOnNewLineForControlBlocks: boolean; +>PlaceOpenBraceOnNewLineForControlBlocks : boolean + } + interface DefinitionInfo { +>DefinitionInfo : DefinitionInfo + + fileName: string; +>fileName : string + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + kind: string; +>kind : string + + name: string; +>name : string + + containerKind: string; +>containerKind : string + + containerName: string; +>containerName : string + } + enum SymbolDisplayPartKind { +>SymbolDisplayPartKind : SymbolDisplayPartKind + + aliasName = 0, +>aliasName : SymbolDisplayPartKind + + className = 1, +>className : SymbolDisplayPartKind + + enumName = 2, +>enumName : SymbolDisplayPartKind + + fieldName = 3, +>fieldName : SymbolDisplayPartKind + + interfaceName = 4, +>interfaceName : SymbolDisplayPartKind + + keyword = 5, +>keyword : SymbolDisplayPartKind + + lineBreak = 6, +>lineBreak : SymbolDisplayPartKind + + numericLiteral = 7, +>numericLiteral : SymbolDisplayPartKind + + stringLiteral = 8, +>stringLiteral : SymbolDisplayPartKind + + localName = 9, +>localName : SymbolDisplayPartKind + + methodName = 10, +>methodName : SymbolDisplayPartKind + + moduleName = 11, +>moduleName : SymbolDisplayPartKind + + operator = 12, +>operator : SymbolDisplayPartKind + + parameterName = 13, +>parameterName : SymbolDisplayPartKind + + propertyName = 14, +>propertyName : SymbolDisplayPartKind + + punctuation = 15, +>punctuation : SymbolDisplayPartKind + + space = 16, +>space : SymbolDisplayPartKind + + text = 17, +>text : SymbolDisplayPartKind + + typeParameterName = 18, +>typeParameterName : SymbolDisplayPartKind + + enumMemberName = 19, +>enumMemberName : SymbolDisplayPartKind + + functionName = 20, +>functionName : SymbolDisplayPartKind + + regularExpressionLiteral = 21, +>regularExpressionLiteral : SymbolDisplayPartKind + } + interface SymbolDisplayPart { +>SymbolDisplayPart : SymbolDisplayPart + + text: string; +>text : string + + kind: string; +>kind : string + } + interface QuickInfo { +>QuickInfo : QuickInfo + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + displayParts: SymbolDisplayPart[]; +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface RenameInfo { +>RenameInfo : RenameInfo + + canRename: boolean; +>canRename : boolean + + localizedErrorMessage: string; +>localizedErrorMessage : string + + displayName: string; +>displayName : string + + fullDisplayName: string; +>fullDisplayName : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + triggerSpan: TextSpan; +>triggerSpan : TextSpan +>TextSpan : TextSpan + } + interface SignatureHelpParameter { +>SignatureHelpParameter : SignatureHelpParameter + + name: string; +>name : string + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + displayParts: SymbolDisplayPart[]; +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + isOptional: boolean; +>isOptional : boolean + } + /** + * Represents a single signature to show in signature help. + * The id is used for subsequent calls into the language service to ask questions about the + * signature help item in the context of any documents that have been updated. i.e. after + * an edit has happened, while signature help is still active, the host can ask important + * questions like 'what parameter is the user currently contained within?'. + */ + interface SignatureHelpItem { +>SignatureHelpItem : SignatureHelpItem + + isVariadic: boolean; +>isVariadic : boolean + + prefixDisplayParts: SymbolDisplayPart[]; +>prefixDisplayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + suffixDisplayParts: SymbolDisplayPart[]; +>suffixDisplayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + separatorDisplayParts: SymbolDisplayPart[]; +>separatorDisplayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + parameters: SignatureHelpParameter[]; +>parameters : SignatureHelpParameter[] +>SignatureHelpParameter : SignatureHelpParameter + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + /** + * Represents a set of signature help items, and the preferred item that should be selected. + */ + interface SignatureHelpItems { +>SignatureHelpItems : SignatureHelpItems + + items: SignatureHelpItem[]; +>items : SignatureHelpItem[] +>SignatureHelpItem : SignatureHelpItem + + applicableSpan: TextSpan; +>applicableSpan : TextSpan +>TextSpan : TextSpan + + selectedItemIndex: number; +>selectedItemIndex : number + + argumentIndex: number; +>argumentIndex : number + + argumentCount: number; +>argumentCount : number + } + interface CompletionInfo { +>CompletionInfo : CompletionInfo + + isMemberCompletion: boolean; +>isMemberCompletion : boolean + + entries: CompletionEntry[]; +>entries : CompletionEntry[] +>CompletionEntry : CompletionEntry + } + interface CompletionEntry { +>CompletionEntry : CompletionEntry + + name: string; +>name : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + } + interface CompletionEntryDetails { +>CompletionEntryDetails : CompletionEntryDetails + + name: string; +>name : string + + kind: string; +>kind : string + + kindModifiers: string; +>kindModifiers : string + + displayParts: SymbolDisplayPart[]; +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + documentation: SymbolDisplayPart[]; +>documentation : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + interface OutliningSpan { +>OutliningSpan : OutliningSpan + + /** The span of the document to actually collapse. */ + textSpan: TextSpan; +>textSpan : TextSpan +>TextSpan : TextSpan + + /** The span of the document to display when the user hovers over the collapsed span. */ + hintSpan: TextSpan; +>hintSpan : TextSpan +>TextSpan : TextSpan + + /** The text to display in the editor for the collapsed region. */ + bannerText: string; +>bannerText : string + + /** + * Whether or not this region should be automatically collapsed when + * the 'Collapse to Definitions' command is invoked. + */ + autoCollapse: boolean; +>autoCollapse : boolean + } + interface EmitOutput { +>EmitOutput : EmitOutput + + outputFiles: OutputFile[]; +>outputFiles : OutputFile[] +>OutputFile : OutputFile + + emitOutputStatus: EmitReturnStatus; +>emitOutputStatus : EmitReturnStatus +>EmitReturnStatus : EmitReturnStatus + } + const enum OutputFileType { +>OutputFileType : OutputFileType + + JavaScript = 0, +>JavaScript : OutputFileType + + SourceMap = 1, +>SourceMap : OutputFileType + + Declaration = 2, +>Declaration : OutputFileType + } + interface OutputFile { +>OutputFile : OutputFile + + name: string; +>name : string + + writeByteOrderMark: boolean; +>writeByteOrderMark : boolean + + text: string; +>text : string + } + const enum EndOfLineState { +>EndOfLineState : EndOfLineState + + Start = 0, +>Start : EndOfLineState + + InMultiLineCommentTrivia = 1, +>InMultiLineCommentTrivia : EndOfLineState + + InSingleQuoteStringLiteral = 2, +>InSingleQuoteStringLiteral : EndOfLineState + + InDoubleQuoteStringLiteral = 3, +>InDoubleQuoteStringLiteral : EndOfLineState + } + enum TokenClass { +>TokenClass : TokenClass + + Punctuation = 0, +>Punctuation : TokenClass + + Keyword = 1, +>Keyword : TokenClass + + Operator = 2, +>Operator : TokenClass + + Comment = 3, +>Comment : TokenClass + + Whitespace = 4, +>Whitespace : TokenClass + + Identifier = 5, +>Identifier : TokenClass + + NumberLiteral = 6, +>NumberLiteral : TokenClass + + StringLiteral = 7, +>StringLiteral : TokenClass + + RegExpLiteral = 8, +>RegExpLiteral : TokenClass + } + interface ClassificationResult { +>ClassificationResult : ClassificationResult + + finalLexState: EndOfLineState; +>finalLexState : EndOfLineState +>EndOfLineState : EndOfLineState + + entries: ClassificationInfo[]; +>entries : ClassificationInfo[] +>ClassificationInfo : ClassificationInfo + } + interface ClassificationInfo { +>ClassificationInfo : ClassificationInfo + + length: number; +>length : number + + classification: TokenClass; +>classification : TokenClass +>TokenClass : TokenClass + } + interface Classifier { +>Classifier : Classifier + + getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult; +>getClassificationsForLine : (text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean) => ClassificationResult +>text : string +>lexState : EndOfLineState +>EndOfLineState : EndOfLineState +>classifyKeywordsInGenerics : boolean +>ClassificationResult : ClassificationResult + } + interface DocumentRegistry { +>DocumentRegistry : DocumentRegistry + + acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile; +>acquireDocument : (filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean) => SourceFile +>filename : string +>compilationSettings : CompilerOptions +>CompilerOptions : CompilerOptions +>scriptSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>version : string +>isOpen : boolean +>SourceFile : SourceFile + + updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile; +>updateDocument : (sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile +>sourceFile : SourceFile +>SourceFile : SourceFile +>filename : string +>compilationSettings : CompilerOptions +>CompilerOptions : CompilerOptions +>scriptSnapshot : IScriptSnapshot +>IScriptSnapshot : IScriptSnapshot +>version : string +>isOpen : boolean +>textChangeRange : TextChangeRange +>TextChangeRange : TextChangeRange +>SourceFile : SourceFile + + releaseDocument(filename: string, compilationSettings: CompilerOptions): void; +>releaseDocument : (filename: string, compilationSettings: CompilerOptions) => void +>filename : string +>compilationSettings : CompilerOptions +>CompilerOptions : CompilerOptions + } + class ScriptElementKind { +>ScriptElementKind : ScriptElementKind + + static unknown: string; +>unknown : string + + static keyword: string; +>keyword : string + + static scriptElement: string; +>scriptElement : string + + static moduleElement: string; +>moduleElement : string + + static classElement: string; +>classElement : string + + static interfaceElement: string; +>interfaceElement : string + + static typeElement: string; +>typeElement : string + + static enumElement: string; +>enumElement : string + + static variableElement: string; +>variableElement : string + + static localVariableElement: string; +>localVariableElement : string + + static functionElement: string; +>functionElement : string + + static localFunctionElement: string; +>localFunctionElement : string + + static memberFunctionElement: string; +>memberFunctionElement : string + + static memberGetAccessorElement: string; +>memberGetAccessorElement : string + + static memberSetAccessorElement: string; +>memberSetAccessorElement : string + + static memberVariableElement: string; +>memberVariableElement : string + + static constructorImplementationElement: string; +>constructorImplementationElement : string + + static callSignatureElement: string; +>callSignatureElement : string + + static indexSignatureElement: string; +>indexSignatureElement : string + + static constructSignatureElement: string; +>constructSignatureElement : string + + static parameterElement: string; +>parameterElement : string + + static typeParameterElement: string; +>typeParameterElement : string + + static primitiveType: string; +>primitiveType : string + + static label: string; +>label : string + + static alias: string; +>alias : string + + static constElement: string; +>constElement : string + + static letElement: string; +>letElement : string + } + class ScriptElementKindModifier { +>ScriptElementKindModifier : ScriptElementKindModifier + + static none: string; +>none : string + + static publicMemberModifier: string; +>publicMemberModifier : string + + static privateMemberModifier: string; +>privateMemberModifier : string + + static protectedMemberModifier: string; +>protectedMemberModifier : string + + static exportedModifier: string; +>exportedModifier : string + + static ambientModifier: string; +>ambientModifier : string + + static staticModifier: string; +>staticModifier : string + } + class ClassificationTypeNames { +>ClassificationTypeNames : ClassificationTypeNames + + static comment: string; +>comment : string + + static identifier: string; +>identifier : string + + static keyword: string; +>keyword : string + + static numericLiteral: string; +>numericLiteral : string + + static operator: string; +>operator : string + + static stringLiteral: string; +>stringLiteral : string + + static whiteSpace: string; +>whiteSpace : string + + static text: string; +>text : string + + static punctuation: string; +>punctuation : string + + static className: string; +>className : string + + static enumName: string; +>enumName : string + + static interfaceName: string; +>interfaceName : string + + static moduleName: string; +>moduleName : string + + static typeParameterName: string; +>typeParameterName : string + } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; +>displayPartsToString : (displayParts: SymbolDisplayPart[]) => string +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + + interface DisplayPartsSymbolWriter extends SymbolWriter { +>DisplayPartsSymbolWriter : DisplayPartsSymbolWriter +>SymbolWriter : SymbolWriter + + displayParts(): SymbolDisplayPart[]; +>displayParts : () => SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + } + function getDefaultCompilerOptions(): CompilerOptions; +>getDefaultCompilerOptions : () => CompilerOptions +>CompilerOptions : CompilerOptions + + class OperationCanceledException { +>OperationCanceledException : OperationCanceledException + } + class CancellationTokenObject { +>CancellationTokenObject : CancellationTokenObject + + private cancellationToken; +>cancellationToken : any + + static None: CancellationTokenObject; +>None : CancellationTokenObject +>CancellationTokenObject : CancellationTokenObject + + constructor(cancellationToken: CancellationToken); +>cancellationToken : CancellationToken +>CancellationToken : CancellationToken + + isCancellationRequested(): boolean; +>isCancellationRequested : () => boolean + + throwIfCancellationRequested(): void; +>throwIfCancellationRequested : () => void + } + function createDocumentRegistry(): DocumentRegistry; +>createDocumentRegistry : () => DocumentRegistry +>DocumentRegistry : DocumentRegistry + + function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo; +>preProcessFile : (sourceText: string, readImportFiles?: boolean) => PreProcessedFileInfo +>sourceText : string +>readImportFiles : boolean +>PreProcessedFileInfo : PreProcessedFileInfo + + function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService; +>createLanguageService : (host: LanguageServiceHost, documentRegistry: DocumentRegistry) => LanguageService +>host : LanguageServiceHost +>LanguageServiceHost : LanguageServiceHost +>documentRegistry : DocumentRegistry +>DocumentRegistry : DocumentRegistry +>LanguageService : LanguageService + + function createClassifier(host: Logger): Classifier; +>createClassifier : (host: Logger) => Classifier +>host : Logger +>Logger : Logger +>Classifier : Classifier +} + diff --git a/tests/cases/compiler/APISample_node_compile.ts b/tests/cases/compiler/APISample_node_compile.ts new file mode 100644 index 0000000000000..b138ce2b44cd1 --- /dev/null +++ b/tests/cases/compiler/APISample_node_compile.ts @@ -0,0 +1,11 @@ +// @includeBuiltFile: typescript.d.ts +// @noImplicitAny: true +// @target: ES3 +// @module: CommonJs +// @noresolve: true + +import ts = require("typescript"); + +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0"); + +var program = ts.createProgram(["file1.ts"], {}, undefined); \ No newline at end of file diff --git a/tests/cases/compiler/APISample_standalone_compile.ts b/tests/cases/compiler/APISample_standalone_compile.ts new file mode 100644 index 0000000000000..049aae5523f98 --- /dev/null +++ b/tests/cases/compiler/APISample_standalone_compile.ts @@ -0,0 +1,7 @@ +// @includeBuiltFile: typescriptServices.d.ts +// @noImplicitAny: true +// @target: ES3 + +var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0"); + +var program = ts.createProgram(["file1.ts"], {}, undefined); \ No newline at end of file From 7fb92f8af0bdb4f5632277677b72019c28e1e710 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 16:57:02 -0800 Subject: [PATCH 16/19] Fixed up baselines. --- .../reference/APISample_node_compile.js | 319 +++++----- .../reference/APISample_node_compile.types | 583 ++++++++++-------- .../reference/APISample_standalone_compile.js | 308 ++++----- .../APISample_standalone_compile.types | 562 ++++++++++------- 4 files changed, 1009 insertions(+), 763 deletions(-) diff --git a/tests/baselines/reference/APISample_node_compile.js b/tests/baselines/reference/APISample_node_compile.js index 2329e7be57cfd..6807d97db8444 100644 --- a/tests/baselines/reference/APISample_node_compile.js +++ b/tests/baselines/reference/APISample_node_compile.js @@ -23,7 +23,7 @@ See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ -declare module ts { +declare module "typescript" { interface Map { [index: string]: T; } @@ -152,92 +152,91 @@ declare module ts { SetKeyword = 117, StringKeyword = 118, TypeKeyword = 119, - Missing = 120, - QualifiedName = 121, - ComputedPropertyName = 122, - TypeParameter = 123, - Parameter = 124, - Property = 125, - Method = 126, - Constructor = 127, - GetAccessor = 128, - SetAccessor = 129, - CallSignature = 130, - ConstructSignature = 131, - IndexSignature = 132, - TypeReference = 133, - FunctionType = 134, - ConstructorType = 135, - TypeQuery = 136, - TypeLiteral = 137, - ArrayType = 138, - TupleType = 139, - UnionType = 140, - ParenthesizedType = 141, - ArrayLiteralExpression = 142, - ObjectLiteralExpression = 143, - PropertyAccessExpression = 144, - ElementAccessExpression = 145, - CallExpression = 146, - NewExpression = 147, - TaggedTemplateExpression = 148, - TypeAssertionExpression = 149, - ParenthesizedExpression = 150, - FunctionExpression = 151, - ArrowFunction = 152, - DeleteExpression = 153, - TypeOfExpression = 154, - VoidExpression = 155, - PrefixUnaryExpression = 156, - PostfixUnaryExpression = 157, - BinaryExpression = 158, - ConditionalExpression = 159, - TemplateExpression = 160, - YieldExpression = 161, - OmittedExpression = 162, - TemplateSpan = 163, - Block = 164, - VariableStatement = 165, - EmptyStatement = 166, - ExpressionStatement = 167, - IfStatement = 168, - DoStatement = 169, - WhileStatement = 170, - ForStatement = 171, - ForInStatement = 172, - ContinueStatement = 173, - BreakStatement = 174, - ReturnStatement = 175, - WithStatement = 176, - SwitchStatement = 177, - LabeledStatement = 178, - ThrowStatement = 179, - TryStatement = 180, - TryBlock = 181, - CatchBlock = 182, - FinallyBlock = 183, - DebuggerStatement = 184, - VariableDeclaration = 185, - FunctionDeclaration = 186, - FunctionBlock = 187, - ClassDeclaration = 188, - InterfaceDeclaration = 189, - TypeAliasDeclaration = 190, - EnumDeclaration = 191, - ModuleDeclaration = 192, - ModuleBlock = 193, - ImportDeclaration = 194, - ExportAssignment = 195, - CaseClause = 196, - DefaultClause = 197, - HeritageClause = 198, - PropertyAssignment = 199, - ShorthandPropertyAssignment = 200, - EnumMember = 201, - SourceFile = 202, - Program = 203, - SyntaxList = 204, - Count = 205, + QualifiedName = 120, + ComputedPropertyName = 121, + TypeParameter = 122, + Parameter = 123, + Property = 124, + Method = 125, + Constructor = 126, + GetAccessor = 127, + SetAccessor = 128, + CallSignature = 129, + ConstructSignature = 130, + IndexSignature = 131, + TypeReference = 132, + FunctionType = 133, + ConstructorType = 134, + TypeQuery = 135, + TypeLiteral = 136, + ArrayType = 137, + TupleType = 138, + UnionType = 139, + ParenthesizedType = 140, + ArrayLiteralExpression = 141, + ObjectLiteralExpression = 142, + PropertyAccessExpression = 143, + ElementAccessExpression = 144, + CallExpression = 145, + NewExpression = 146, + TaggedTemplateExpression = 147, + TypeAssertionExpression = 148, + ParenthesizedExpression = 149, + FunctionExpression = 150, + ArrowFunction = 151, + DeleteExpression = 152, + TypeOfExpression = 153, + VoidExpression = 154, + PrefixUnaryExpression = 155, + PostfixUnaryExpression = 156, + BinaryExpression = 157, + ConditionalExpression = 158, + TemplateExpression = 159, + YieldExpression = 160, + OmittedExpression = 161, + TemplateSpan = 162, + Block = 163, + VariableStatement = 164, + EmptyStatement = 165, + ExpressionStatement = 166, + IfStatement = 167, + DoStatement = 168, + WhileStatement = 169, + ForStatement = 170, + ForInStatement = 171, + ContinueStatement = 172, + BreakStatement = 173, + ReturnStatement = 174, + WithStatement = 175, + SwitchStatement = 176, + LabeledStatement = 177, + ThrowStatement = 178, + TryStatement = 179, + TryBlock = 180, + FinallyBlock = 181, + DebuggerStatement = 182, + VariableDeclaration = 183, + FunctionDeclaration = 184, + ClassDeclaration = 185, + InterfaceDeclaration = 186, + TypeAliasDeclaration = 187, + EnumDeclaration = 188, + ModuleDeclaration = 189, + ModuleBlock = 190, + ImportDeclaration = 191, + ExportAssignment = 192, + ExternalModuleReference = 193, + CaseClause = 194, + DefaultClause = 195, + HeritageClause = 196, + CatchClause = 197, + PropertyAssignment = 198, + ShorthandPropertyAssignment = 199, + EnumMember = 200, + SourceFile = 201, + Program = 202, + SyntaxList = 203, + Count = 204, FirstAssignment = 51, LastAssignment = 62, FirstReservedWord = 64, @@ -246,11 +245,11 @@ declare module ts { LastKeyword = 119, FirstFutureReservedWord = 100, LastFutureReservedWord = 108, - FirstTypeNode = 133, - LastTypeNode = 141, + FirstTypeNode = 132, + LastTypeNode = 140, FirstPunctuation = 13, LastPunctuation = 62, - FirstToken = 1, + FirstToken = 0, LastToken = 119, FirstTriviaToken = 2, LastTriviaToken = 5, @@ -262,12 +261,11 @@ declare module ts { LastOperator = 62, FirstBinaryOperator = 23, LastBinaryOperator = 62, + FirstNode = 120, } const enum NodeFlags { Export = 1, Ambient = 2, - QuestionMark = 4, - Rest = 8, Public = 16, Private = 32, Protected = 64, @@ -287,6 +285,8 @@ declare module ts { DisallowIn = 2, Yield = 4, GeneratorParameter = 8, + ContainsError = 16, + HasPropagatedChildContainsErrorFlag = 32, } interface Node extends TextRange { kind: SyntaxKind; @@ -303,7 +303,7 @@ declare module ts { interface NodeArray extends Array, TextRange { hasTrailingComma?: boolean; } - interface ModifiersArray extends Array { + interface ModifiersArray extends NodeArray { flags: number; } interface Identifier extends PrimaryExpression { @@ -314,11 +314,6 @@ declare module ts { right: Identifier; } type EntityName = Identifier | QualifiedName; - interface ParsedSignature { - typeParameters?: NodeArray; - parameters: NodeArray; - type?: TypeNode; - } type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; interface Declaration extends Node { _declarationBrand: any; @@ -332,21 +327,43 @@ declare module ts { constraint?: TypeNode; expression?: Expression; } - interface SignatureDeclaration extends Declaration, ParsedSignature { + interface SignatureDeclaration extends Declaration { + typeParameters?: NodeArray; + parameters: NodeArray; + type?: TypeNode; } interface VariableDeclaration extends Declaration { name: Identifier; type?: TypeNode; initializer?: Expression; } + interface ParameterDeclaration extends Declaration { + dotDotDotToken?: Node; + name: Identifier; + questionToken?: Node; + type?: TypeNode | StringLiteralExpression; + initializer?: Expression; + } interface PropertyDeclaration extends Declaration, ClassElement { + _propertyDeclarationBrand: any; + questionToken?: Node; type?: TypeNode; initializer?: Expression; } - interface ShortHandPropertyDeclaration extends Declaration { + type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration; + type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration; + interface ObjectLiteralElement extends Declaration { + _objectLiteralBrandBrand: any; + } + interface ShorthandPropertyAssignment extends ObjectLiteralElement { name: Identifier; + questionToken?: Node; } - interface ParameterDeclaration extends VariableDeclaration { + interface PropertyAssignment extends ObjectLiteralElement { + _propertyAssignmentBrand: any; + name: DeclarationName; + questionToken?: Node; + initializer: Expression; } /** * Several node kinds share function-like features such as a signature, @@ -359,25 +376,31 @@ declare module ts { interface FunctionLikeDeclaration extends SignatureDeclaration { _functionLikeDeclarationBrand: any; asteriskToken?: Node; + questionToken?: Node; body?: Block | Expression; } interface FunctionDeclaration extends FunctionLikeDeclaration, Statement { name: Identifier; body?: Block; } - interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { body?: Block; } interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement { body?: Block; } - interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { - body?: Block; + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { + _accessorDeclarationBrand: any; + body: Block; } interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement { _indexSignatureDeclarationBrand: any; } interface TypeNode extends Node { + _typeNodeBrand: any; + } + interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration { + _functionOrConstructorTypeNodeBrand: any; } interface TypeReferenceNode extends TypeNode { typeName: EntityName; @@ -401,9 +424,6 @@ declare module ts { interface ParenthesizedTypeNode extends TypeNode { type: TypeNode; } - interface StringLiteralTypeNode extends TypeNode { - text: string; - } interface Expression extends Node { _expressionBrand: any; contextualType?: Type; @@ -460,6 +480,10 @@ declare module ts { } interface LiteralExpression extends PrimaryExpression { text: string; + isUnterminated?: boolean; + } + interface StringLiteralExpression extends LiteralExpression { + _stringLiteralExpressionBrand: any; } interface TemplateExpression extends PrimaryExpression { head: LiteralExpression; @@ -476,7 +500,7 @@ declare module ts { elements: NodeArray; } interface ObjectLiteralExpression extends PrimaryExpression, Declaration { - properties: NodeArray; + properties: NodeArray; } interface PropertyAccessExpression extends MemberExpression { expression: LeftHandSideExpression; @@ -484,7 +508,7 @@ declare module ts { } interface ElementAccessExpression extends MemberExpression { expression: LeftHandSideExpression; - argumentExpression: Expression; + argumentExpression?: Expression; } interface CallExpression extends LeftHandSideExpression { expression: LeftHandSideExpression; @@ -553,10 +577,14 @@ declare module ts { expression: Expression; clauses: NodeArray; } - interface CaseOrDefaultClause extends Node { + interface CaseClause extends Node { expression?: Expression; statements: NodeArray; } + interface DefaultClause extends Node { + statements: NodeArray; + } + type CaseOrDefaultClause = CaseClause | DefaultClause; interface LabeledStatement extends Statement { label: Identifier; statement: Statement; @@ -566,12 +594,13 @@ declare module ts { } interface TryStatement extends Statement { tryBlock: Block; - catchBlock?: CatchBlock; + catchClause?: CatchClause; finallyBlock?: Block; } - interface CatchBlock extends Block, Declaration { - variable: Identifier; + interface CatchClause extends Declaration { + name: Identifier; type?: TypeNode; + block: Block; } interface ModuleElement extends Node { _moduleElementBrand: any; @@ -616,8 +645,10 @@ declare module ts { } interface ImportDeclaration extends Declaration, ModuleElement { name: Identifier; - entityName?: EntityName; - externalModuleName?: LiteralExpression; + moduleReference: EntityName | ExternalModuleReference; + } + interface ExternalModuleReference extends Node { + expression?: Expression; } interface ExportAssignment extends Statement, ModuleElement { exportName: Identifier; @@ -630,6 +661,7 @@ declare module ts { } interface SourceFile extends Declaration { statements: NodeArray; + endOfFileToken: Node; filename: string; text: string; getLineAndCharacterFromPosition(position: number): LineAndCharacter; @@ -638,10 +670,11 @@ declare module ts { amdDependencies: string[]; amdModuleName: string; referencedFiles: FileReference[]; - semanticDiagnostics: Diagnostic[]; + referenceDiagnostics: Diagnostic[]; parseDiagnostics: Diagnostic[]; grammarDiagnostics: Diagnostic[]; getSyntacticDiagnostics(): Diagnostic[]; + semanticDiagnostics: Diagnostic[]; hasNoDefaultLib: boolean; externalModuleIndicator: Node; nodeCount: number; @@ -703,10 +736,8 @@ declare module ts { getIdentifierCount(): number; getSymbolCount(): number; getTypeCount(): number; - checkProgram(): void; emitFiles(targetSourceFile?: SourceFile): EmitResult; - getParentOfSymbol(symbol: Symbol): Symbol; - getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; + getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type; getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol; @@ -714,16 +745,16 @@ declare module ts { getIndexTypeOfType(type: Type, kind: IndexKind): Type; getReturnTypeOfSignature(signature: Signature): Type; getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; - getSymbolInfo(node: Node): Symbol; + getSymbolAtLocation(node: Node): Symbol; getShorthandAssignmentValueSymbol(location: Node): Symbol; - getTypeOfNode(node: Node): Type; + getTypeAtLocation(node: Node): Type; typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; getSymbolDisplayBuilder(): SymbolDisplayBuilder; getFullyQualifiedName(symbol: Symbol): string; getAugmentedPropertiesOfType(type: Type): Symbol[]; getRootSymbols(symbol: Symbol): Symbol[]; - getContextualType(node: Node): Type; + getContextualType(node: Expression): Type; getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature; isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; @@ -797,10 +828,10 @@ declare module ts { isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; getNodeCheckFlags(node: Node): NodeCheckFlags; getEnumMemberValue(node: EnumMember): number; - hasSemanticErrors(): boolean; + hasSemanticErrors(sourceFile?: SourceFile): boolean; isDeclarationVisible(node: Declaration): boolean; isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; - writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; + writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult; isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult; @@ -944,7 +975,6 @@ declare module ts { StringLike = 258, NumberLike = 132, ObjectType = 48128, - Structured = 65025, } interface Type { flags: TypeFlags; @@ -1057,12 +1087,6 @@ declare module ts { * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit */ isEarly?: boolean; - /** - * Parse error - error produced by parser when it scanner returns a token - * that parser does not understand in its current state - * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) - */ - isParseError?: boolean; } enum DiagnosticCategory { Warning = 0, @@ -1094,6 +1118,7 @@ declare module ts { version?: boolean; watch?: boolean; preserveConstEnums?: boolean; + allowNonTsExtensions?: boolean; [option: string]: string | number | boolean; } const enum ModuleKind { @@ -1254,7 +1279,7 @@ declare module ts { } interface CompilerHost { getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; - getDefaultLibFilename(): string; + getDefaultLibFilename(options: CompilerOptions): string; getCancellationToken?(): CancellationToken; writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; getCurrentDirectory(): string; @@ -1263,7 +1288,7 @@ declare module ts { getNewLine(): string; } } -declare module ts { +declare module "typescript" { interface ErrorCallback { (message: DiagnosticMessage): void; } @@ -1280,12 +1305,14 @@ declare module ts { hasPrecedingLineBreak(): boolean; isIdentifier(): boolean; isReservedWord(): boolean; + isUnterminated(): boolean; reScanGreaterToken(): SyntaxKind; reScanSlashToken(): SyntaxKind; reScanTemplateToken(): SyntaxKind; scan(): SyntaxKind; setText(text: string): void; setTextPos(textPos: number): void; + lookAhead(callback: () => T): T; tryScan(callback: () => T): T; } function tokenToString(t: SyntaxKind): string; @@ -1307,23 +1334,19 @@ declare module ts { function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; - function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner; } -declare module ts { - interface ReferencePathMatchResult { - fileReference?: FileReference; - diagnostic?: DiagnosticMessage; - isNoDefaultLib?: boolean; - } +declare module "typescript" { function getNodeConstructor(kind: SyntaxKind): new () => Node; function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program; } -declare module ts { +declare module "typescript" { function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker; } -declare module ts { +declare module "typescript" { + var servicesVersion: string; interface Node { getSourceFile(): SourceFile; getChildCount(sourceFile?: SourceFile): number; @@ -1411,10 +1434,10 @@ declare module ts { getScriptVersion(fileName: string): string; getScriptIsOpen(fileName: string): boolean; getScriptSnapshot(fileName: string): IScriptSnapshot; - getLocalizedDiagnosticMessages(): any; - getCancellationToken(): CancellationToken; + getLocalizedDiagnosticMessages?(): any; + getCancellationToken?(): CancellationToken; getCurrentDirectory(): string; - getDefaultLibFilename(): string; + getDefaultLibFilename(options: CompilerOptions): string; } interface LanguageService { cleanupSemanticCache(): void; @@ -1423,7 +1446,7 @@ declare module ts { getCompilerOptionsDiagnostics(): Diagnostic[]; getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; - getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; + getCompletionsAtPosition(fileName: string, position: number): CompletionInfo; getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan; @@ -1811,11 +1834,12 @@ declare module ts { static interfaceName: string; static moduleName: string; static typeParameterName: string; + static typeAlias: string; } - function displayPartsToString(displayParts: SymbolDisplayPart[]): string; interface DisplayPartsSymbolWriter extends SymbolWriter { displayParts(): SymbolDisplayPart[]; } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; function getDefaultCompilerOptions(): CompilerOptions; class OperationCanceledException { } @@ -1832,7 +1856,6 @@ declare module ts { function createClassifier(host: Logger): Classifier; } -export = ts; //// [APISample_node_compile.js] var ts = require("typescript"); diff --git a/tests/baselines/reference/APISample_node_compile.types b/tests/baselines/reference/APISample_node_compile.types index 15aa4b13a2e01..4331fb28c72b4 100644 --- a/tests/baselines/reference/APISample_node_compile.types +++ b/tests/baselines/reference/APISample_node_compile.types @@ -41,9 +41,7 @@ See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ -declare module ts { ->ts : typeof ts - +declare module "typescript" { interface Map { >Map : Map >T : T @@ -424,262 +422,259 @@ declare module ts { TypeKeyword = 119, >TypeKeyword : SyntaxKind - Missing = 120, ->Missing : SyntaxKind - - QualifiedName = 121, + QualifiedName = 120, >QualifiedName : SyntaxKind - ComputedPropertyName = 122, + ComputedPropertyName = 121, >ComputedPropertyName : SyntaxKind - TypeParameter = 123, + TypeParameter = 122, >TypeParameter : SyntaxKind - Parameter = 124, + Parameter = 123, >Parameter : SyntaxKind - Property = 125, + Property = 124, >Property : SyntaxKind - Method = 126, + Method = 125, >Method : SyntaxKind - Constructor = 127, + Constructor = 126, >Constructor : SyntaxKind - GetAccessor = 128, + GetAccessor = 127, >GetAccessor : SyntaxKind - SetAccessor = 129, + SetAccessor = 128, >SetAccessor : SyntaxKind - CallSignature = 130, + CallSignature = 129, >CallSignature : SyntaxKind - ConstructSignature = 131, + ConstructSignature = 130, >ConstructSignature : SyntaxKind - IndexSignature = 132, + IndexSignature = 131, >IndexSignature : SyntaxKind - TypeReference = 133, + TypeReference = 132, >TypeReference : SyntaxKind - FunctionType = 134, + FunctionType = 133, >FunctionType : SyntaxKind - ConstructorType = 135, + ConstructorType = 134, >ConstructorType : SyntaxKind - TypeQuery = 136, + TypeQuery = 135, >TypeQuery : SyntaxKind - TypeLiteral = 137, + TypeLiteral = 136, >TypeLiteral : SyntaxKind - ArrayType = 138, + ArrayType = 137, >ArrayType : SyntaxKind - TupleType = 139, + TupleType = 138, >TupleType : SyntaxKind - UnionType = 140, + UnionType = 139, >UnionType : SyntaxKind - ParenthesizedType = 141, + ParenthesizedType = 140, >ParenthesizedType : SyntaxKind - ArrayLiteralExpression = 142, + ArrayLiteralExpression = 141, >ArrayLiteralExpression : SyntaxKind - ObjectLiteralExpression = 143, + ObjectLiteralExpression = 142, >ObjectLiteralExpression : SyntaxKind - PropertyAccessExpression = 144, + PropertyAccessExpression = 143, >PropertyAccessExpression : SyntaxKind - ElementAccessExpression = 145, + ElementAccessExpression = 144, >ElementAccessExpression : SyntaxKind - CallExpression = 146, + CallExpression = 145, >CallExpression : SyntaxKind - NewExpression = 147, + NewExpression = 146, >NewExpression : SyntaxKind - TaggedTemplateExpression = 148, + TaggedTemplateExpression = 147, >TaggedTemplateExpression : SyntaxKind - TypeAssertionExpression = 149, + TypeAssertionExpression = 148, >TypeAssertionExpression : SyntaxKind - ParenthesizedExpression = 150, + ParenthesizedExpression = 149, >ParenthesizedExpression : SyntaxKind - FunctionExpression = 151, + FunctionExpression = 150, >FunctionExpression : SyntaxKind - ArrowFunction = 152, + ArrowFunction = 151, >ArrowFunction : SyntaxKind - DeleteExpression = 153, + DeleteExpression = 152, >DeleteExpression : SyntaxKind - TypeOfExpression = 154, + TypeOfExpression = 153, >TypeOfExpression : SyntaxKind - VoidExpression = 155, + VoidExpression = 154, >VoidExpression : SyntaxKind - PrefixUnaryExpression = 156, + PrefixUnaryExpression = 155, >PrefixUnaryExpression : SyntaxKind - PostfixUnaryExpression = 157, + PostfixUnaryExpression = 156, >PostfixUnaryExpression : SyntaxKind - BinaryExpression = 158, + BinaryExpression = 157, >BinaryExpression : SyntaxKind - ConditionalExpression = 159, + ConditionalExpression = 158, >ConditionalExpression : SyntaxKind - TemplateExpression = 160, + TemplateExpression = 159, >TemplateExpression : SyntaxKind - YieldExpression = 161, + YieldExpression = 160, >YieldExpression : SyntaxKind - OmittedExpression = 162, + OmittedExpression = 161, >OmittedExpression : SyntaxKind - TemplateSpan = 163, + TemplateSpan = 162, >TemplateSpan : SyntaxKind - Block = 164, + Block = 163, >Block : SyntaxKind - VariableStatement = 165, + VariableStatement = 164, >VariableStatement : SyntaxKind - EmptyStatement = 166, + EmptyStatement = 165, >EmptyStatement : SyntaxKind - ExpressionStatement = 167, + ExpressionStatement = 166, >ExpressionStatement : SyntaxKind - IfStatement = 168, + IfStatement = 167, >IfStatement : SyntaxKind - DoStatement = 169, + DoStatement = 168, >DoStatement : SyntaxKind - WhileStatement = 170, + WhileStatement = 169, >WhileStatement : SyntaxKind - ForStatement = 171, + ForStatement = 170, >ForStatement : SyntaxKind - ForInStatement = 172, + ForInStatement = 171, >ForInStatement : SyntaxKind - ContinueStatement = 173, + ContinueStatement = 172, >ContinueStatement : SyntaxKind - BreakStatement = 174, + BreakStatement = 173, >BreakStatement : SyntaxKind - ReturnStatement = 175, + ReturnStatement = 174, >ReturnStatement : SyntaxKind - WithStatement = 176, + WithStatement = 175, >WithStatement : SyntaxKind - SwitchStatement = 177, + SwitchStatement = 176, >SwitchStatement : SyntaxKind - LabeledStatement = 178, + LabeledStatement = 177, >LabeledStatement : SyntaxKind - ThrowStatement = 179, + ThrowStatement = 178, >ThrowStatement : SyntaxKind - TryStatement = 180, + TryStatement = 179, >TryStatement : SyntaxKind - TryBlock = 181, + TryBlock = 180, >TryBlock : SyntaxKind - CatchBlock = 182, ->CatchBlock : SyntaxKind - - FinallyBlock = 183, + FinallyBlock = 181, >FinallyBlock : SyntaxKind - DebuggerStatement = 184, + DebuggerStatement = 182, >DebuggerStatement : SyntaxKind - VariableDeclaration = 185, + VariableDeclaration = 183, >VariableDeclaration : SyntaxKind - FunctionDeclaration = 186, + FunctionDeclaration = 184, >FunctionDeclaration : SyntaxKind - FunctionBlock = 187, ->FunctionBlock : SyntaxKind - - ClassDeclaration = 188, + ClassDeclaration = 185, >ClassDeclaration : SyntaxKind - InterfaceDeclaration = 189, + InterfaceDeclaration = 186, >InterfaceDeclaration : SyntaxKind - TypeAliasDeclaration = 190, + TypeAliasDeclaration = 187, >TypeAliasDeclaration : SyntaxKind - EnumDeclaration = 191, + EnumDeclaration = 188, >EnumDeclaration : SyntaxKind - ModuleDeclaration = 192, + ModuleDeclaration = 189, >ModuleDeclaration : SyntaxKind - ModuleBlock = 193, + ModuleBlock = 190, >ModuleBlock : SyntaxKind - ImportDeclaration = 194, + ImportDeclaration = 191, >ImportDeclaration : SyntaxKind - ExportAssignment = 195, + ExportAssignment = 192, >ExportAssignment : SyntaxKind - CaseClause = 196, + ExternalModuleReference = 193, +>ExternalModuleReference : SyntaxKind + + CaseClause = 194, >CaseClause : SyntaxKind - DefaultClause = 197, + DefaultClause = 195, >DefaultClause : SyntaxKind - HeritageClause = 198, + HeritageClause = 196, >HeritageClause : SyntaxKind - PropertyAssignment = 199, + CatchClause = 197, +>CatchClause : SyntaxKind + + PropertyAssignment = 198, >PropertyAssignment : SyntaxKind - ShorthandPropertyAssignment = 200, + ShorthandPropertyAssignment = 199, >ShorthandPropertyAssignment : SyntaxKind - EnumMember = 201, + EnumMember = 200, >EnumMember : SyntaxKind - SourceFile = 202, + SourceFile = 201, >SourceFile : SyntaxKind - Program = 203, + Program = 202, >Program : SyntaxKind - SyntaxList = 204, + SyntaxList = 203, >SyntaxList : SyntaxKind - Count = 205, + Count = 204, >Count : SyntaxKind FirstAssignment = 51, @@ -706,10 +701,10 @@ declare module ts { LastFutureReservedWord = 108, >LastFutureReservedWord : SyntaxKind - FirstTypeNode = 133, + FirstTypeNode = 132, >FirstTypeNode : SyntaxKind - LastTypeNode = 141, + LastTypeNode = 140, >LastTypeNode : SyntaxKind FirstPunctuation = 13, @@ -718,7 +713,7 @@ declare module ts { LastPunctuation = 62, >LastPunctuation : SyntaxKind - FirstToken = 1, + FirstToken = 0, >FirstToken : SyntaxKind LastToken = 119, @@ -753,6 +748,9 @@ declare module ts { LastBinaryOperator = 62, >LastBinaryOperator : SyntaxKind + + FirstNode = 120, +>FirstNode : SyntaxKind } const enum NodeFlags { >NodeFlags : NodeFlags @@ -763,12 +761,6 @@ declare module ts { Ambient = 2, >Ambient : NodeFlags - QuestionMark = 4, ->QuestionMark : NodeFlags - - Rest = 8, ->Rest : NodeFlags - Public = 16, >Public : NodeFlags @@ -822,6 +814,12 @@ declare module ts { GeneratorParameter = 8, >GeneratorParameter : ParserContextFlags + + ContainsError = 16, +>ContainsError : ParserContextFlags + + HasPropagatedChildContainsErrorFlag = 32, +>HasPropagatedChildContainsErrorFlag : ParserContextFlags } interface Node extends TextRange { >Node : Node @@ -876,9 +874,9 @@ declare module ts { hasTrailingComma?: boolean; >hasTrailingComma : boolean } - interface ModifiersArray extends Array { + interface ModifiersArray extends NodeArray { >ModifiersArray : ModifiersArray ->Array : T[] +>NodeArray : NodeArray >Node : Node flags: number; @@ -908,23 +906,6 @@ declare module ts { >Identifier : Identifier >QualifiedName : QualifiedName - interface ParsedSignature { ->ParsedSignature : ParsedSignature - - typeParameters?: NodeArray; ->typeParameters : NodeArray ->NodeArray : NodeArray ->TypeParameterDeclaration : TypeParameterDeclaration - - parameters: NodeArray; ->parameters : NodeArray ->NodeArray : NodeArray ->ParameterDeclaration : ParameterDeclaration - - type?: TypeNode; ->type : TypeNode ->TypeNode : TypeNode - } type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; >DeclarationName : Identifier | LiteralExpression | ComputedPropertyName >Identifier : Identifier @@ -966,10 +947,23 @@ declare module ts { >expression : Expression >Expression : Expression } - interface SignatureDeclaration extends Declaration, ParsedSignature { + interface SignatureDeclaration extends Declaration { >SignatureDeclaration : SignatureDeclaration >Declaration : Declaration ->ParsedSignature : ParsedSignature + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + parameters: NodeArray; +>parameters : NodeArray +>NodeArray : NodeArray +>ParameterDeclaration : ParameterDeclaration + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode } interface VariableDeclaration extends Declaration { >VariableDeclaration : VariableDeclaration @@ -985,6 +979,31 @@ declare module ts { initializer?: Expression; >initializer : Expression +>Expression : Expression + } + interface ParameterDeclaration extends Declaration { +>ParameterDeclaration : ParameterDeclaration +>Declaration : Declaration + + dotDotDotToken?: Node; +>dotDotDotToken : Node +>Node : Node + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + questionToken?: Node; +>questionToken : Node +>Node : Node + + type?: TypeNode | StringLiteralExpression; +>type : TypeNode | StringLiteralExpression +>TypeNode : TypeNode +>StringLiteralExpression : StringLiteralExpression + + initializer?: Expression; +>initializer : Expression >Expression : Expression } interface PropertyDeclaration extends Declaration, ClassElement { @@ -992,6 +1011,13 @@ declare module ts { >Declaration : Declaration >ClassElement : ClassElement + _propertyDeclarationBrand: any; +>_propertyDeclarationBrand : any + + questionToken?: Node; +>questionToken : Node +>Node : Node + type?: TypeNode; >type : TypeNode >TypeNode : TypeNode @@ -1000,17 +1026,53 @@ declare module ts { >initializer : Expression >Expression : Expression } - interface ShortHandPropertyDeclaration extends Declaration { ->ShortHandPropertyDeclaration : ShortHandPropertyDeclaration + type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration; +>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration +>VariableDeclaration : VariableDeclaration +>ParameterDeclaration : ParameterDeclaration + + type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration; +>VariableOrParameterOrPropertyDeclaration : ParameterDeclaration | VariableDeclaration | PropertyDeclaration +>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration +>PropertyDeclaration : PropertyDeclaration + + interface ObjectLiteralElement extends Declaration { +>ObjectLiteralElement : ObjectLiteralElement >Declaration : Declaration + _objectLiteralBrandBrand: any; +>_objectLiteralBrandBrand : any + } + interface ShorthandPropertyAssignment extends ObjectLiteralElement { +>ShorthandPropertyAssignment : ShorthandPropertyAssignment +>ObjectLiteralElement : ObjectLiteralElement + name: Identifier; >name : Identifier >Identifier : Identifier + + questionToken?: Node; +>questionToken : Node +>Node : Node } - interface ParameterDeclaration extends VariableDeclaration { ->ParameterDeclaration : ParameterDeclaration ->VariableDeclaration : VariableDeclaration + interface PropertyAssignment extends ObjectLiteralElement { +>PropertyAssignment : PropertyAssignment +>ObjectLiteralElement : ObjectLiteralElement + + _propertyAssignmentBrand: any; +>_propertyAssignmentBrand : any + + name: DeclarationName; +>name : Identifier | LiteralExpression | ComputedPropertyName +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName + + questionToken?: Node; +>questionToken : Node +>Node : Node + + initializer: Expression; +>initializer : Expression +>Expression : Expression } /** * Several node kinds share function-like features such as a signature, @@ -1029,6 +1091,10 @@ declare module ts { asteriskToken?: Node; >asteriskToken : Node +>Node : Node + + questionToken?: Node; +>questionToken : Node >Node : Node body?: Block | Expression; @@ -1049,10 +1115,11 @@ declare module ts { >body : Block >Block : Block } - interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { >MethodDeclaration : MethodDeclaration >FunctionLikeDeclaration : FunctionLikeDeclaration >ClassElement : ClassElement +>ObjectLiteralElement : ObjectLiteralElement body?: Block; >body : Block @@ -1067,12 +1134,16 @@ declare module ts { >body : Block >Block : Block } - interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { >AccessorDeclaration : AccessorDeclaration >FunctionLikeDeclaration : FunctionLikeDeclaration >ClassElement : ClassElement +>ObjectLiteralElement : ObjectLiteralElement - body?: Block; + _accessorDeclarationBrand: any; +>_accessorDeclarationBrand : any + + body: Block; >body : Block >Block : Block } @@ -1087,6 +1158,17 @@ declare module ts { interface TypeNode extends Node { >TypeNode : TypeNode >Node : Node + + _typeNodeBrand: any; +>_typeNodeBrand : any + } + interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration { +>FunctionOrConstructorTypeNode : FunctionOrConstructorTypeNode +>TypeNode : TypeNode +>SignatureDeclaration : SignatureDeclaration + + _functionOrConstructorTypeNodeBrand: any; +>_functionOrConstructorTypeNodeBrand : any } interface TypeReferenceNode extends TypeNode { >TypeReferenceNode : TypeReferenceNode @@ -1152,13 +1234,6 @@ declare module ts { type: TypeNode; >type : TypeNode >TypeNode : TypeNode - } - interface StringLiteralTypeNode extends TypeNode { ->StringLiteralTypeNode : StringLiteralTypeNode ->TypeNode : TypeNode - - text: string; ->text : string } interface Expression extends Node { >Expression : Expression @@ -1318,6 +1393,16 @@ declare module ts { text: string; >text : string + + isUnterminated?: boolean; +>isUnterminated : boolean + } + interface StringLiteralExpression extends LiteralExpression { +>StringLiteralExpression : StringLiteralExpression +>LiteralExpression : LiteralExpression + + _stringLiteralExpressionBrand: any; +>_stringLiteralExpressionBrand : any } interface TemplateExpression extends PrimaryExpression { >TemplateExpression : TemplateExpression @@ -1366,10 +1451,10 @@ declare module ts { >PrimaryExpression : PrimaryExpression >Declaration : Declaration - properties: NodeArray; ->properties : NodeArray + properties: NodeArray; +>properties : NodeArray >NodeArray : NodeArray ->Declaration : Declaration +>ObjectLiteralElement : ObjectLiteralElement } interface PropertyAccessExpression extends MemberExpression { >PropertyAccessExpression : PropertyAccessExpression @@ -1391,7 +1476,7 @@ declare module ts { >expression : LeftHandSideExpression >LeftHandSideExpression : LeftHandSideExpression - argumentExpression: Expression; + argumentExpression?: Expression; >argumentExpression : Expression >Expression : Expression } @@ -1598,12 +1683,12 @@ declare module ts { >Expression : Expression clauses: NodeArray; ->clauses : NodeArray +>clauses : NodeArray >NodeArray : NodeArray ->CaseOrDefaultClause : CaseOrDefaultClause +>CaseOrDefaultClause : CaseClause | DefaultClause } - interface CaseOrDefaultClause extends Node { ->CaseOrDefaultClause : CaseOrDefaultClause + interface CaseClause extends Node { +>CaseClause : CaseClause >Node : Node expression?: Expression; @@ -1615,6 +1700,20 @@ declare module ts { >NodeArray : NodeArray >Statement : Statement } + interface DefaultClause extends Node { +>DefaultClause : DefaultClause +>Node : Node + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>Statement : Statement + } + type CaseOrDefaultClause = CaseClause | DefaultClause; +>CaseOrDefaultClause : CaseClause | DefaultClause +>CaseClause : CaseClause +>DefaultClause : DefaultClause + interface LabeledStatement extends Statement { >LabeledStatement : LabeledStatement >Statement : Statement @@ -1643,26 +1742,29 @@ declare module ts { >tryBlock : Block >Block : Block - catchBlock?: CatchBlock; ->catchBlock : CatchBlock ->CatchBlock : CatchBlock + catchClause?: CatchClause; +>catchClause : CatchClause +>CatchClause : CatchClause finallyBlock?: Block; >finallyBlock : Block >Block : Block } - interface CatchBlock extends Block, Declaration { ->CatchBlock : CatchBlock ->Block : Block + interface CatchClause extends Declaration { +>CatchClause : CatchClause >Declaration : Declaration - variable: Identifier; ->variable : Identifier + name: Identifier; +>name : Identifier >Identifier : Identifier type?: TypeNode; >type : TypeNode >TypeNode : TypeNode + + block: Block; +>block : Block +>Block : Block } interface ModuleElement extends Node { >ModuleElement : ModuleElement @@ -1812,13 +1914,18 @@ declare module ts { >name : Identifier >Identifier : Identifier - entityName?: EntityName; ->entityName : Identifier | QualifiedName + moduleReference: EntityName | ExternalModuleReference; +>moduleReference : Identifier | QualifiedName | ExternalModuleReference >EntityName : Identifier | QualifiedName +>ExternalModuleReference : ExternalModuleReference + } + interface ExternalModuleReference extends Node { +>ExternalModuleReference : ExternalModuleReference +>Node : Node - externalModuleName?: LiteralExpression; ->externalModuleName : LiteralExpression ->LiteralExpression : LiteralExpression + expression?: Expression; +>expression : Expression +>Expression : Expression } interface ExportAssignment extends Statement, ModuleElement { >ExportAssignment : ExportAssignment @@ -1852,6 +1959,10 @@ declare module ts { >NodeArray : NodeArray >ModuleElement : ModuleElement + endOfFileToken: Node; +>endOfFileToken : Node +>Node : Node + filename: string; >filename : string @@ -1881,8 +1992,8 @@ declare module ts { >referencedFiles : FileReference[] >FileReference : FileReference - semanticDiagnostics: Diagnostic[]; ->semanticDiagnostics : Diagnostic[] + referenceDiagnostics: Diagnostic[]; +>referenceDiagnostics : Diagnostic[] >Diagnostic : Diagnostic parseDiagnostics: Diagnostic[]; @@ -1895,6 +2006,10 @@ declare module ts { getSyntacticDiagnostics(): Diagnostic[]; >getSyntacticDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + semanticDiagnostics: Diagnostic[]; +>semanticDiagnostics : Diagnostic[] >Diagnostic : Diagnostic hasNoDefaultLib: boolean; @@ -2088,23 +2203,14 @@ declare module ts { getTypeCount(): number; >getTypeCount : () => number - checkProgram(): void; ->checkProgram : () => void - emitFiles(targetSourceFile?: SourceFile): EmitResult; >emitFiles : (targetSourceFile?: SourceFile) => EmitResult >targetSourceFile : SourceFile >SourceFile : SourceFile >EmitResult : EmitResult - getParentOfSymbol(symbol: Symbol): Symbol; ->getParentOfSymbol : (symbol: Symbol) => Symbol ->symbol : Symbol ->Symbol : Symbol ->Symbol : Symbol - - getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; ->getNarrowedTypeOfSymbol : (symbol: Symbol, node: Node) => Type + getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type; +>getTypeOfSymbolAtLocation : (symbol: Symbol, node: Node) => Type >symbol : Symbol >Symbol : Symbol >node : Node @@ -2160,8 +2266,8 @@ declare module ts { >SymbolFlags : SymbolFlags >Symbol : Symbol - getSymbolInfo(node: Node): Symbol; ->getSymbolInfo : (node: Node) => Symbol + getSymbolAtLocation(node: Node): Symbol; +>getSymbolAtLocation : (node: Node) => Symbol >node : Node >Node : Node >Symbol : Symbol @@ -2172,8 +2278,8 @@ declare module ts { >Node : Node >Symbol : Symbol - getTypeOfNode(node: Node): Type; ->getTypeOfNode : (node: Node) => Type + getTypeAtLocation(node: Node): Type; +>getTypeAtLocation : (node: Node) => Type >node : Node >Node : Node >Type : Type @@ -2217,10 +2323,10 @@ declare module ts { >Symbol : Symbol >Symbol : Symbol - getContextualType(node: Node): Type; ->getContextualType : (node: Node) => Type ->node : Node ->Node : Node + getContextualType(node: Expression): Type; +>getContextualType : (node: Expression) => Type +>node : Expression +>Expression : Expression >Type : Type getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; @@ -2553,8 +2659,10 @@ declare module ts { >node : EnumMember >EnumMember : EnumMember - hasSemanticErrors(): boolean; ->hasSemanticErrors : () => boolean + hasSemanticErrors(sourceFile?: SourceFile): boolean; +>hasSemanticErrors : (sourceFile?: SourceFile) => boolean +>sourceFile : SourceFile +>SourceFile : SourceFile isDeclarationVisible(node: Declaration): boolean; >isDeclarationVisible : (node: Declaration) => boolean @@ -2566,10 +2674,11 @@ declare module ts { >node : FunctionLikeDeclaration >FunctionLikeDeclaration : FunctionLikeDeclaration - writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; ->writeTypeAtLocation : (location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void ->location : Node ->Node : Node + writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; +>writeTypeOfDeclaration : (declaration: ParameterDeclaration | VariableDeclaration | AccessorDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void +>declaration : ParameterDeclaration | VariableDeclaration | AccessorDeclaration +>AccessorDeclaration : AccessorDeclaration +>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration >enclosingDeclaration : Node >Node : Node >flags : TypeFormatFlags @@ -3027,9 +3136,6 @@ declare module ts { ObjectType = 48128, >ObjectType : TypeFlags - - Structured = 65025, ->Structured : TypeFlags } interface Type { >Type : Type @@ -3361,14 +3467,6 @@ declare module ts { */ isEarly?: boolean; >isEarly : boolean - - /** - * Parse error - error produced by parser when it scanner returns a token - * that parser does not understand in its current state - * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) - */ - isParseError?: boolean; ->isParseError : boolean } enum DiagnosticCategory { >DiagnosticCategory : DiagnosticCategory @@ -3459,6 +3557,9 @@ declare module ts { preserveConstEnums?: boolean; >preserveConstEnums : boolean + allowNonTsExtensions?: boolean; +>allowNonTsExtensions : boolean + [option: string]: string | number | boolean; >option : string } @@ -3927,8 +4028,10 @@ declare module ts { >message : string >SourceFile : SourceFile - getDefaultLibFilename(): string; ->getDefaultLibFilename : () => string + getDefaultLibFilename(options: CompilerOptions): string; +>getDefaultLibFilename : (options: CompilerOptions) => string +>options : CompilerOptions +>CompilerOptions : CompilerOptions getCancellationToken?(): CancellationToken; >getCancellationToken : () => CancellationToken @@ -3956,9 +4059,7 @@ declare module ts { >getNewLine : () => string } } -declare module ts { ->ts : typeof ts - +declare module "typescript" { interface ErrorCallback { >ErrorCallback : ErrorCallback @@ -4004,6 +4105,9 @@ declare module ts { isReservedWord(): boolean; >isReservedWord : () => boolean + isUnterminated(): boolean; +>isUnterminated : () => boolean + reScanGreaterToken(): SyntaxKind; >reScanGreaterToken : () => SyntaxKind >SyntaxKind : SyntaxKind @@ -4028,6 +4132,13 @@ declare module ts { >setTextPos : (textPos: number) => void >textPos : number + lookAhead(callback: () => T): T; +>lookAhead : (callback: () => T) => T +>T : T +>callback : () => T +>T : T +>T : T + tryScan(callback: () => T): T; >tryScan : (callback: () => T) => T >T : T @@ -4116,35 +4227,17 @@ declare module ts { >languageVersion : ScriptTarget >ScriptTarget : ScriptTarget - function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; ->createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback) => Scanner + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner; +>createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback) => Scanner >languageVersion : ScriptTarget >ScriptTarget : ScriptTarget >skipTrivia : boolean >text : string >onError : ErrorCallback >ErrorCallback : ErrorCallback ->onComment : CommentCallback ->CommentCallback : CommentCallback >Scanner : Scanner } -declare module ts { ->ts : typeof ts - - interface ReferencePathMatchResult { ->ReferencePathMatchResult : ReferencePathMatchResult - - fileReference?: FileReference; ->fileReference : FileReference ->FileReference : FileReference - - diagnostic?: DiagnosticMessage; ->diagnostic : DiagnosticMessage ->DiagnosticMessage : DiagnosticMessage - - isNoDefaultLib?: boolean; ->isNoDefaultLib : boolean - } +declare module "typescript" { function getNodeConstructor(kind: SyntaxKind): new () => Node; >getNodeConstructor : (kind: SyntaxKind) => new () => Node >kind : SyntaxKind @@ -4185,9 +4278,7 @@ declare module ts { >CompilerHost : CompilerHost >Program : Program } -declare module ts { ->ts : typeof ts - +declare module "typescript" { function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker; >createTypeChecker : (program: Program, fullTypeCheck: boolean) => TypeChecker >program : Program @@ -4195,8 +4286,9 @@ declare module ts { >fullTypeCheck : boolean >TypeChecker : TypeChecker } -declare module ts { ->ts : typeof ts +declare module "typescript" { + var servicesVersion: string; +>servicesVersion : string interface Node { >Node : Node @@ -4463,18 +4555,20 @@ declare module ts { >fileName : string >IScriptSnapshot : IScriptSnapshot - getLocalizedDiagnosticMessages(): any; + getLocalizedDiagnosticMessages?(): any; >getLocalizedDiagnosticMessages : () => any - getCancellationToken(): CancellationToken; + getCancellationToken?(): CancellationToken; >getCancellationToken : () => CancellationToken >CancellationToken : CancellationToken getCurrentDirectory(): string; >getCurrentDirectory : () => string - getDefaultLibFilename(): string; ->getDefaultLibFilename : () => string + getDefaultLibFilename(options: CompilerOptions): string; +>getDefaultLibFilename : (options: CompilerOptions) => string +>options : CompilerOptions +>CompilerOptions : CompilerOptions } interface LanguageService { >LanguageService : LanguageService @@ -4510,11 +4604,10 @@ declare module ts { >TextSpan : TextSpan >ClassifiedSpan : ClassifiedSpan - getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; ->getCompletionsAtPosition : (fileName: string, position: number, isMemberCompletion: boolean) => CompletionInfo + getCompletionsAtPosition(fileName: string, position: number): CompletionInfo; +>getCompletionsAtPosition : (fileName: string, position: number) => CompletionInfo >fileName : string >position : number ->isMemberCompletion : boolean >CompletionInfo : CompletionInfo getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; @@ -5576,12 +5669,10 @@ declare module ts { static typeParameterName: string; >typeParameterName : string - } - function displayPartsToString(displayParts: SymbolDisplayPart[]): string; ->displayPartsToString : (displayParts: SymbolDisplayPart[]) => string ->displayParts : SymbolDisplayPart[] ->SymbolDisplayPart : SymbolDisplayPart + static typeAlias: string; +>typeAlias : string + } interface DisplayPartsSymbolWriter extends SymbolWriter { >DisplayPartsSymbolWriter : DisplayPartsSymbolWriter >SymbolWriter : SymbolWriter @@ -5590,6 +5681,11 @@ declare module ts { >displayParts : () => SymbolDisplayPart[] >SymbolDisplayPart : SymbolDisplayPart } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; +>displayPartsToString : (displayParts: SymbolDisplayPart[]) => string +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + function getDefaultCompilerOptions(): CompilerOptions; >getDefaultCompilerOptions : () => CompilerOptions >CompilerOptions : CompilerOptions @@ -5641,7 +5737,4 @@ declare module ts { >Logger : Logger >Classifier : Classifier } - -export = ts; ->ts : typeof ts diff --git a/tests/baselines/reference/APISample_standalone_compile.js b/tests/baselines/reference/APISample_standalone_compile.js index e1f55f8a4c221..fff2226f320a8 100644 --- a/tests/baselines/reference/APISample_standalone_compile.js +++ b/tests/baselines/reference/APISample_standalone_compile.js @@ -150,92 +150,91 @@ declare module ts { SetKeyword = 117, StringKeyword = 118, TypeKeyword = 119, - Missing = 120, - QualifiedName = 121, - ComputedPropertyName = 122, - TypeParameter = 123, - Parameter = 124, - Property = 125, - Method = 126, - Constructor = 127, - GetAccessor = 128, - SetAccessor = 129, - CallSignature = 130, - ConstructSignature = 131, - IndexSignature = 132, - TypeReference = 133, - FunctionType = 134, - ConstructorType = 135, - TypeQuery = 136, - TypeLiteral = 137, - ArrayType = 138, - TupleType = 139, - UnionType = 140, - ParenthesizedType = 141, - ArrayLiteralExpression = 142, - ObjectLiteralExpression = 143, - PropertyAccessExpression = 144, - ElementAccessExpression = 145, - CallExpression = 146, - NewExpression = 147, - TaggedTemplateExpression = 148, - TypeAssertionExpression = 149, - ParenthesizedExpression = 150, - FunctionExpression = 151, - ArrowFunction = 152, - DeleteExpression = 153, - TypeOfExpression = 154, - VoidExpression = 155, - PrefixUnaryExpression = 156, - PostfixUnaryExpression = 157, - BinaryExpression = 158, - ConditionalExpression = 159, - TemplateExpression = 160, - YieldExpression = 161, - OmittedExpression = 162, - TemplateSpan = 163, - Block = 164, - VariableStatement = 165, - EmptyStatement = 166, - ExpressionStatement = 167, - IfStatement = 168, - DoStatement = 169, - WhileStatement = 170, - ForStatement = 171, - ForInStatement = 172, - ContinueStatement = 173, - BreakStatement = 174, - ReturnStatement = 175, - WithStatement = 176, - SwitchStatement = 177, - LabeledStatement = 178, - ThrowStatement = 179, - TryStatement = 180, - TryBlock = 181, - CatchBlock = 182, - FinallyBlock = 183, - DebuggerStatement = 184, - VariableDeclaration = 185, - FunctionDeclaration = 186, - FunctionBlock = 187, - ClassDeclaration = 188, - InterfaceDeclaration = 189, - TypeAliasDeclaration = 190, - EnumDeclaration = 191, - ModuleDeclaration = 192, - ModuleBlock = 193, - ImportDeclaration = 194, - ExportAssignment = 195, - CaseClause = 196, - DefaultClause = 197, - HeritageClause = 198, - PropertyAssignment = 199, - ShorthandPropertyAssignment = 200, - EnumMember = 201, - SourceFile = 202, - Program = 203, - SyntaxList = 204, - Count = 205, + QualifiedName = 120, + ComputedPropertyName = 121, + TypeParameter = 122, + Parameter = 123, + Property = 124, + Method = 125, + Constructor = 126, + GetAccessor = 127, + SetAccessor = 128, + CallSignature = 129, + ConstructSignature = 130, + IndexSignature = 131, + TypeReference = 132, + FunctionType = 133, + ConstructorType = 134, + TypeQuery = 135, + TypeLiteral = 136, + ArrayType = 137, + TupleType = 138, + UnionType = 139, + ParenthesizedType = 140, + ArrayLiteralExpression = 141, + ObjectLiteralExpression = 142, + PropertyAccessExpression = 143, + ElementAccessExpression = 144, + CallExpression = 145, + NewExpression = 146, + TaggedTemplateExpression = 147, + TypeAssertionExpression = 148, + ParenthesizedExpression = 149, + FunctionExpression = 150, + ArrowFunction = 151, + DeleteExpression = 152, + TypeOfExpression = 153, + VoidExpression = 154, + PrefixUnaryExpression = 155, + PostfixUnaryExpression = 156, + BinaryExpression = 157, + ConditionalExpression = 158, + TemplateExpression = 159, + YieldExpression = 160, + OmittedExpression = 161, + TemplateSpan = 162, + Block = 163, + VariableStatement = 164, + EmptyStatement = 165, + ExpressionStatement = 166, + IfStatement = 167, + DoStatement = 168, + WhileStatement = 169, + ForStatement = 170, + ForInStatement = 171, + ContinueStatement = 172, + BreakStatement = 173, + ReturnStatement = 174, + WithStatement = 175, + SwitchStatement = 176, + LabeledStatement = 177, + ThrowStatement = 178, + TryStatement = 179, + TryBlock = 180, + FinallyBlock = 181, + DebuggerStatement = 182, + VariableDeclaration = 183, + FunctionDeclaration = 184, + ClassDeclaration = 185, + InterfaceDeclaration = 186, + TypeAliasDeclaration = 187, + EnumDeclaration = 188, + ModuleDeclaration = 189, + ModuleBlock = 190, + ImportDeclaration = 191, + ExportAssignment = 192, + ExternalModuleReference = 193, + CaseClause = 194, + DefaultClause = 195, + HeritageClause = 196, + CatchClause = 197, + PropertyAssignment = 198, + ShorthandPropertyAssignment = 199, + EnumMember = 200, + SourceFile = 201, + Program = 202, + SyntaxList = 203, + Count = 204, FirstAssignment = 51, LastAssignment = 62, FirstReservedWord = 64, @@ -244,11 +243,11 @@ declare module ts { LastKeyword = 119, FirstFutureReservedWord = 100, LastFutureReservedWord = 108, - FirstTypeNode = 133, - LastTypeNode = 141, + FirstTypeNode = 132, + LastTypeNode = 140, FirstPunctuation = 13, LastPunctuation = 62, - FirstToken = 1, + FirstToken = 0, LastToken = 119, FirstTriviaToken = 2, LastTriviaToken = 5, @@ -260,12 +259,11 @@ declare module ts { LastOperator = 62, FirstBinaryOperator = 23, LastBinaryOperator = 62, + FirstNode = 120, } const enum NodeFlags { Export = 1, Ambient = 2, - QuestionMark = 4, - Rest = 8, Public = 16, Private = 32, Protected = 64, @@ -285,6 +283,8 @@ declare module ts { DisallowIn = 2, Yield = 4, GeneratorParameter = 8, + ContainsError = 16, + HasPropagatedChildContainsErrorFlag = 32, } interface Node extends TextRange { kind: SyntaxKind; @@ -301,7 +301,7 @@ declare module ts { interface NodeArray extends Array, TextRange { hasTrailingComma?: boolean; } - interface ModifiersArray extends Array { + interface ModifiersArray extends NodeArray { flags: number; } interface Identifier extends PrimaryExpression { @@ -312,11 +312,6 @@ declare module ts { right: Identifier; } type EntityName = Identifier | QualifiedName; - interface ParsedSignature { - typeParameters?: NodeArray; - parameters: NodeArray; - type?: TypeNode; - } type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; interface Declaration extends Node { _declarationBrand: any; @@ -330,21 +325,43 @@ declare module ts { constraint?: TypeNode; expression?: Expression; } - interface SignatureDeclaration extends Declaration, ParsedSignature { + interface SignatureDeclaration extends Declaration { + typeParameters?: NodeArray; + parameters: NodeArray; + type?: TypeNode; } interface VariableDeclaration extends Declaration { name: Identifier; type?: TypeNode; initializer?: Expression; } + interface ParameterDeclaration extends Declaration { + dotDotDotToken?: Node; + name: Identifier; + questionToken?: Node; + type?: TypeNode | StringLiteralExpression; + initializer?: Expression; + } interface PropertyDeclaration extends Declaration, ClassElement { + _propertyDeclarationBrand: any; + questionToken?: Node; type?: TypeNode; initializer?: Expression; } - interface ShortHandPropertyDeclaration extends Declaration { + type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration; + type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration; + interface ObjectLiteralElement extends Declaration { + _objectLiteralBrandBrand: any; + } + interface ShorthandPropertyAssignment extends ObjectLiteralElement { name: Identifier; + questionToken?: Node; } - interface ParameterDeclaration extends VariableDeclaration { + interface PropertyAssignment extends ObjectLiteralElement { + _propertyAssignmentBrand: any; + name: DeclarationName; + questionToken?: Node; + initializer: Expression; } /** * Several node kinds share function-like features such as a signature, @@ -357,25 +374,31 @@ declare module ts { interface FunctionLikeDeclaration extends SignatureDeclaration { _functionLikeDeclarationBrand: any; asteriskToken?: Node; + questionToken?: Node; body?: Block | Expression; } interface FunctionDeclaration extends FunctionLikeDeclaration, Statement { name: Identifier; body?: Block; } - interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { body?: Block; } interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement { body?: Block; } - interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { - body?: Block; + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { + _accessorDeclarationBrand: any; + body: Block; } interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement { _indexSignatureDeclarationBrand: any; } interface TypeNode extends Node { + _typeNodeBrand: any; + } + interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration { + _functionOrConstructorTypeNodeBrand: any; } interface TypeReferenceNode extends TypeNode { typeName: EntityName; @@ -399,9 +422,6 @@ declare module ts { interface ParenthesizedTypeNode extends TypeNode { type: TypeNode; } - interface StringLiteralTypeNode extends TypeNode { - text: string; - } interface Expression extends Node { _expressionBrand: any; contextualType?: Type; @@ -458,6 +478,10 @@ declare module ts { } interface LiteralExpression extends PrimaryExpression { text: string; + isUnterminated?: boolean; + } + interface StringLiteralExpression extends LiteralExpression { + _stringLiteralExpressionBrand: any; } interface TemplateExpression extends PrimaryExpression { head: LiteralExpression; @@ -474,7 +498,7 @@ declare module ts { elements: NodeArray; } interface ObjectLiteralExpression extends PrimaryExpression, Declaration { - properties: NodeArray; + properties: NodeArray; } interface PropertyAccessExpression extends MemberExpression { expression: LeftHandSideExpression; @@ -482,7 +506,7 @@ declare module ts { } interface ElementAccessExpression extends MemberExpression { expression: LeftHandSideExpression; - argumentExpression: Expression; + argumentExpression?: Expression; } interface CallExpression extends LeftHandSideExpression { expression: LeftHandSideExpression; @@ -551,10 +575,14 @@ declare module ts { expression: Expression; clauses: NodeArray; } - interface CaseOrDefaultClause extends Node { + interface CaseClause extends Node { expression?: Expression; statements: NodeArray; } + interface DefaultClause extends Node { + statements: NodeArray; + } + type CaseOrDefaultClause = CaseClause | DefaultClause; interface LabeledStatement extends Statement { label: Identifier; statement: Statement; @@ -564,12 +592,13 @@ declare module ts { } interface TryStatement extends Statement { tryBlock: Block; - catchBlock?: CatchBlock; + catchClause?: CatchClause; finallyBlock?: Block; } - interface CatchBlock extends Block, Declaration { - variable: Identifier; + interface CatchClause extends Declaration { + name: Identifier; type?: TypeNode; + block: Block; } interface ModuleElement extends Node { _moduleElementBrand: any; @@ -614,8 +643,10 @@ declare module ts { } interface ImportDeclaration extends Declaration, ModuleElement { name: Identifier; - entityName?: EntityName; - externalModuleName?: LiteralExpression; + moduleReference: EntityName | ExternalModuleReference; + } + interface ExternalModuleReference extends Node { + expression?: Expression; } interface ExportAssignment extends Statement, ModuleElement { exportName: Identifier; @@ -628,6 +659,7 @@ declare module ts { } interface SourceFile extends Declaration { statements: NodeArray; + endOfFileToken: Node; filename: string; text: string; getLineAndCharacterFromPosition(position: number): LineAndCharacter; @@ -636,10 +668,11 @@ declare module ts { amdDependencies: string[]; amdModuleName: string; referencedFiles: FileReference[]; - semanticDiagnostics: Diagnostic[]; + referenceDiagnostics: Diagnostic[]; parseDiagnostics: Diagnostic[]; grammarDiagnostics: Diagnostic[]; getSyntacticDiagnostics(): Diagnostic[]; + semanticDiagnostics: Diagnostic[]; hasNoDefaultLib: boolean; externalModuleIndicator: Node; nodeCount: number; @@ -701,10 +734,8 @@ declare module ts { getIdentifierCount(): number; getSymbolCount(): number; getTypeCount(): number; - checkProgram(): void; emitFiles(targetSourceFile?: SourceFile): EmitResult; - getParentOfSymbol(symbol: Symbol): Symbol; - getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; + getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type; getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol; @@ -712,16 +743,16 @@ declare module ts { getIndexTypeOfType(type: Type, kind: IndexKind): Type; getReturnTypeOfSignature(signature: Signature): Type; getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; - getSymbolInfo(node: Node): Symbol; + getSymbolAtLocation(node: Node): Symbol; getShorthandAssignmentValueSymbol(location: Node): Symbol; - getTypeOfNode(node: Node): Type; + getTypeAtLocation(node: Node): Type; typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; getSymbolDisplayBuilder(): SymbolDisplayBuilder; getFullyQualifiedName(symbol: Symbol): string; getAugmentedPropertiesOfType(type: Type): Symbol[]; getRootSymbols(symbol: Symbol): Symbol[]; - getContextualType(node: Node): Type; + getContextualType(node: Expression): Type; getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature; isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; @@ -795,10 +826,10 @@ declare module ts { isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; getNodeCheckFlags(node: Node): NodeCheckFlags; getEnumMemberValue(node: EnumMember): number; - hasSemanticErrors(): boolean; + hasSemanticErrors(sourceFile?: SourceFile): boolean; isDeclarationVisible(node: Declaration): boolean; isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; - writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; + writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult; isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult; @@ -942,7 +973,6 @@ declare module ts { StringLike = 258, NumberLike = 132, ObjectType = 48128, - Structured = 65025, } interface Type { flags: TypeFlags; @@ -1055,12 +1085,6 @@ declare module ts { * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit */ isEarly?: boolean; - /** - * Parse error - error produced by parser when it scanner returns a token - * that parser does not understand in its current state - * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) - */ - isParseError?: boolean; } enum DiagnosticCategory { Warning = 0, @@ -1092,6 +1116,7 @@ declare module ts { version?: boolean; watch?: boolean; preserveConstEnums?: boolean; + allowNonTsExtensions?: boolean; [option: string]: string | number | boolean; } const enum ModuleKind { @@ -1252,7 +1277,7 @@ declare module ts { } interface CompilerHost { getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; - getDefaultLibFilename(): string; + getDefaultLibFilename(options: CompilerOptions): string; getCancellationToken?(): CancellationToken; writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; getCurrentDirectory(): string; @@ -1278,12 +1303,14 @@ declare module ts { hasPrecedingLineBreak(): boolean; isIdentifier(): boolean; isReservedWord(): boolean; + isUnterminated(): boolean; reScanGreaterToken(): SyntaxKind; reScanSlashToken(): SyntaxKind; reScanTemplateToken(): SyntaxKind; scan(): SyntaxKind; setText(text: string): void; setTextPos(textPos: number): void; + lookAhead(callback: () => T): T; tryScan(callback: () => T): T; } function tokenToString(t: SyntaxKind): string; @@ -1305,14 +1332,9 @@ declare module ts { function getTrailingCommentRanges(text: string, pos: number): CommentRange[]; function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; - function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner; } declare module ts { - interface ReferencePathMatchResult { - fileReference?: FileReference; - diagnostic?: DiagnosticMessage; - isNoDefaultLib?: boolean; - } function getNodeConstructor(kind: SyntaxKind): new () => Node; function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; @@ -1322,6 +1344,7 @@ declare module ts { function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker; } declare module ts { + var servicesVersion: string; interface Node { getSourceFile(): SourceFile; getChildCount(sourceFile?: SourceFile): number; @@ -1409,10 +1432,10 @@ declare module ts { getScriptVersion(fileName: string): string; getScriptIsOpen(fileName: string): boolean; getScriptSnapshot(fileName: string): IScriptSnapshot; - getLocalizedDiagnosticMessages(): any; - getCancellationToken(): CancellationToken; + getLocalizedDiagnosticMessages?(): any; + getCancellationToken?(): CancellationToken; getCurrentDirectory(): string; - getDefaultLibFilename(): string; + getDefaultLibFilename(options: CompilerOptions): string; } interface LanguageService { cleanupSemanticCache(): void; @@ -1421,7 +1444,7 @@ declare module ts { getCompilerOptionsDiagnostics(): Diagnostic[]; getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; - getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; + getCompletionsAtPosition(fileName: string, position: number): CompletionInfo; getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan; @@ -1809,11 +1832,12 @@ declare module ts { static interfaceName: string; static moduleName: string; static typeParameterName: string; + static typeAlias: string; } - function displayPartsToString(displayParts: SymbolDisplayPart[]): string; interface DisplayPartsSymbolWriter extends SymbolWriter { displayParts(): SymbolDisplayPart[]; } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; function getDefaultCompilerOptions(): CompilerOptions; class OperationCanceledException { } diff --git a/tests/baselines/reference/APISample_standalone_compile.types b/tests/baselines/reference/APISample_standalone_compile.types index ebde76e4aa4d3..c69e655aec1a0 100644 --- a/tests/baselines/reference/APISample_standalone_compile.types +++ b/tests/baselines/reference/APISample_standalone_compile.types @@ -421,262 +421,259 @@ declare module ts { TypeKeyword = 119, >TypeKeyword : SyntaxKind - Missing = 120, ->Missing : SyntaxKind - - QualifiedName = 121, + QualifiedName = 120, >QualifiedName : SyntaxKind - ComputedPropertyName = 122, + ComputedPropertyName = 121, >ComputedPropertyName : SyntaxKind - TypeParameter = 123, + TypeParameter = 122, >TypeParameter : SyntaxKind - Parameter = 124, + Parameter = 123, >Parameter : SyntaxKind - Property = 125, + Property = 124, >Property : SyntaxKind - Method = 126, + Method = 125, >Method : SyntaxKind - Constructor = 127, + Constructor = 126, >Constructor : SyntaxKind - GetAccessor = 128, + GetAccessor = 127, >GetAccessor : SyntaxKind - SetAccessor = 129, + SetAccessor = 128, >SetAccessor : SyntaxKind - CallSignature = 130, + CallSignature = 129, >CallSignature : SyntaxKind - ConstructSignature = 131, + ConstructSignature = 130, >ConstructSignature : SyntaxKind - IndexSignature = 132, + IndexSignature = 131, >IndexSignature : SyntaxKind - TypeReference = 133, + TypeReference = 132, >TypeReference : SyntaxKind - FunctionType = 134, + FunctionType = 133, >FunctionType : SyntaxKind - ConstructorType = 135, + ConstructorType = 134, >ConstructorType : SyntaxKind - TypeQuery = 136, + TypeQuery = 135, >TypeQuery : SyntaxKind - TypeLiteral = 137, + TypeLiteral = 136, >TypeLiteral : SyntaxKind - ArrayType = 138, + ArrayType = 137, >ArrayType : SyntaxKind - TupleType = 139, + TupleType = 138, >TupleType : SyntaxKind - UnionType = 140, + UnionType = 139, >UnionType : SyntaxKind - ParenthesizedType = 141, + ParenthesizedType = 140, >ParenthesizedType : SyntaxKind - ArrayLiteralExpression = 142, + ArrayLiteralExpression = 141, >ArrayLiteralExpression : SyntaxKind - ObjectLiteralExpression = 143, + ObjectLiteralExpression = 142, >ObjectLiteralExpression : SyntaxKind - PropertyAccessExpression = 144, + PropertyAccessExpression = 143, >PropertyAccessExpression : SyntaxKind - ElementAccessExpression = 145, + ElementAccessExpression = 144, >ElementAccessExpression : SyntaxKind - CallExpression = 146, + CallExpression = 145, >CallExpression : SyntaxKind - NewExpression = 147, + NewExpression = 146, >NewExpression : SyntaxKind - TaggedTemplateExpression = 148, + TaggedTemplateExpression = 147, >TaggedTemplateExpression : SyntaxKind - TypeAssertionExpression = 149, + TypeAssertionExpression = 148, >TypeAssertionExpression : SyntaxKind - ParenthesizedExpression = 150, + ParenthesizedExpression = 149, >ParenthesizedExpression : SyntaxKind - FunctionExpression = 151, + FunctionExpression = 150, >FunctionExpression : SyntaxKind - ArrowFunction = 152, + ArrowFunction = 151, >ArrowFunction : SyntaxKind - DeleteExpression = 153, + DeleteExpression = 152, >DeleteExpression : SyntaxKind - TypeOfExpression = 154, + TypeOfExpression = 153, >TypeOfExpression : SyntaxKind - VoidExpression = 155, + VoidExpression = 154, >VoidExpression : SyntaxKind - PrefixUnaryExpression = 156, + PrefixUnaryExpression = 155, >PrefixUnaryExpression : SyntaxKind - PostfixUnaryExpression = 157, + PostfixUnaryExpression = 156, >PostfixUnaryExpression : SyntaxKind - BinaryExpression = 158, + BinaryExpression = 157, >BinaryExpression : SyntaxKind - ConditionalExpression = 159, + ConditionalExpression = 158, >ConditionalExpression : SyntaxKind - TemplateExpression = 160, + TemplateExpression = 159, >TemplateExpression : SyntaxKind - YieldExpression = 161, + YieldExpression = 160, >YieldExpression : SyntaxKind - OmittedExpression = 162, + OmittedExpression = 161, >OmittedExpression : SyntaxKind - TemplateSpan = 163, + TemplateSpan = 162, >TemplateSpan : SyntaxKind - Block = 164, + Block = 163, >Block : SyntaxKind - VariableStatement = 165, + VariableStatement = 164, >VariableStatement : SyntaxKind - EmptyStatement = 166, + EmptyStatement = 165, >EmptyStatement : SyntaxKind - ExpressionStatement = 167, + ExpressionStatement = 166, >ExpressionStatement : SyntaxKind - IfStatement = 168, + IfStatement = 167, >IfStatement : SyntaxKind - DoStatement = 169, + DoStatement = 168, >DoStatement : SyntaxKind - WhileStatement = 170, + WhileStatement = 169, >WhileStatement : SyntaxKind - ForStatement = 171, + ForStatement = 170, >ForStatement : SyntaxKind - ForInStatement = 172, + ForInStatement = 171, >ForInStatement : SyntaxKind - ContinueStatement = 173, + ContinueStatement = 172, >ContinueStatement : SyntaxKind - BreakStatement = 174, + BreakStatement = 173, >BreakStatement : SyntaxKind - ReturnStatement = 175, + ReturnStatement = 174, >ReturnStatement : SyntaxKind - WithStatement = 176, + WithStatement = 175, >WithStatement : SyntaxKind - SwitchStatement = 177, + SwitchStatement = 176, >SwitchStatement : SyntaxKind - LabeledStatement = 178, + LabeledStatement = 177, >LabeledStatement : SyntaxKind - ThrowStatement = 179, + ThrowStatement = 178, >ThrowStatement : SyntaxKind - TryStatement = 180, + TryStatement = 179, >TryStatement : SyntaxKind - TryBlock = 181, + TryBlock = 180, >TryBlock : SyntaxKind - CatchBlock = 182, ->CatchBlock : SyntaxKind - - FinallyBlock = 183, + FinallyBlock = 181, >FinallyBlock : SyntaxKind - DebuggerStatement = 184, + DebuggerStatement = 182, >DebuggerStatement : SyntaxKind - VariableDeclaration = 185, + VariableDeclaration = 183, >VariableDeclaration : SyntaxKind - FunctionDeclaration = 186, + FunctionDeclaration = 184, >FunctionDeclaration : SyntaxKind - FunctionBlock = 187, ->FunctionBlock : SyntaxKind - - ClassDeclaration = 188, + ClassDeclaration = 185, >ClassDeclaration : SyntaxKind - InterfaceDeclaration = 189, + InterfaceDeclaration = 186, >InterfaceDeclaration : SyntaxKind - TypeAliasDeclaration = 190, + TypeAliasDeclaration = 187, >TypeAliasDeclaration : SyntaxKind - EnumDeclaration = 191, + EnumDeclaration = 188, >EnumDeclaration : SyntaxKind - ModuleDeclaration = 192, + ModuleDeclaration = 189, >ModuleDeclaration : SyntaxKind - ModuleBlock = 193, + ModuleBlock = 190, >ModuleBlock : SyntaxKind - ImportDeclaration = 194, + ImportDeclaration = 191, >ImportDeclaration : SyntaxKind - ExportAssignment = 195, + ExportAssignment = 192, >ExportAssignment : SyntaxKind - CaseClause = 196, + ExternalModuleReference = 193, +>ExternalModuleReference : SyntaxKind + + CaseClause = 194, >CaseClause : SyntaxKind - DefaultClause = 197, + DefaultClause = 195, >DefaultClause : SyntaxKind - HeritageClause = 198, + HeritageClause = 196, >HeritageClause : SyntaxKind - PropertyAssignment = 199, + CatchClause = 197, +>CatchClause : SyntaxKind + + PropertyAssignment = 198, >PropertyAssignment : SyntaxKind - ShorthandPropertyAssignment = 200, + ShorthandPropertyAssignment = 199, >ShorthandPropertyAssignment : SyntaxKind - EnumMember = 201, + EnumMember = 200, >EnumMember : SyntaxKind - SourceFile = 202, + SourceFile = 201, >SourceFile : SyntaxKind - Program = 203, + Program = 202, >Program : SyntaxKind - SyntaxList = 204, + SyntaxList = 203, >SyntaxList : SyntaxKind - Count = 205, + Count = 204, >Count : SyntaxKind FirstAssignment = 51, @@ -703,10 +700,10 @@ declare module ts { LastFutureReservedWord = 108, >LastFutureReservedWord : SyntaxKind - FirstTypeNode = 133, + FirstTypeNode = 132, >FirstTypeNode : SyntaxKind - LastTypeNode = 141, + LastTypeNode = 140, >LastTypeNode : SyntaxKind FirstPunctuation = 13, @@ -715,7 +712,7 @@ declare module ts { LastPunctuation = 62, >LastPunctuation : SyntaxKind - FirstToken = 1, + FirstToken = 0, >FirstToken : SyntaxKind LastToken = 119, @@ -750,6 +747,9 @@ declare module ts { LastBinaryOperator = 62, >LastBinaryOperator : SyntaxKind + + FirstNode = 120, +>FirstNode : SyntaxKind } const enum NodeFlags { >NodeFlags : NodeFlags @@ -760,12 +760,6 @@ declare module ts { Ambient = 2, >Ambient : NodeFlags - QuestionMark = 4, ->QuestionMark : NodeFlags - - Rest = 8, ->Rest : NodeFlags - Public = 16, >Public : NodeFlags @@ -819,6 +813,12 @@ declare module ts { GeneratorParameter = 8, >GeneratorParameter : ParserContextFlags + + ContainsError = 16, +>ContainsError : ParserContextFlags + + HasPropagatedChildContainsErrorFlag = 32, +>HasPropagatedChildContainsErrorFlag : ParserContextFlags } interface Node extends TextRange { >Node : Node @@ -873,9 +873,9 @@ declare module ts { hasTrailingComma?: boolean; >hasTrailingComma : boolean } - interface ModifiersArray extends Array { + interface ModifiersArray extends NodeArray { >ModifiersArray : ModifiersArray ->Array : T[] +>NodeArray : NodeArray >Node : Node flags: number; @@ -905,23 +905,6 @@ declare module ts { >Identifier : Identifier >QualifiedName : QualifiedName - interface ParsedSignature { ->ParsedSignature : ParsedSignature - - typeParameters?: NodeArray; ->typeParameters : NodeArray ->NodeArray : NodeArray ->TypeParameterDeclaration : TypeParameterDeclaration - - parameters: NodeArray; ->parameters : NodeArray ->NodeArray : NodeArray ->ParameterDeclaration : ParameterDeclaration - - type?: TypeNode; ->type : TypeNode ->TypeNode : TypeNode - } type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName; >DeclarationName : Identifier | LiteralExpression | ComputedPropertyName >Identifier : Identifier @@ -963,10 +946,23 @@ declare module ts { >expression : Expression >Expression : Expression } - interface SignatureDeclaration extends Declaration, ParsedSignature { + interface SignatureDeclaration extends Declaration { >SignatureDeclaration : SignatureDeclaration >Declaration : Declaration ->ParsedSignature : ParsedSignature + + typeParameters?: NodeArray; +>typeParameters : NodeArray +>NodeArray : NodeArray +>TypeParameterDeclaration : TypeParameterDeclaration + + parameters: NodeArray; +>parameters : NodeArray +>NodeArray : NodeArray +>ParameterDeclaration : ParameterDeclaration + + type?: TypeNode; +>type : TypeNode +>TypeNode : TypeNode } interface VariableDeclaration extends Declaration { >VariableDeclaration : VariableDeclaration @@ -982,6 +978,31 @@ declare module ts { initializer?: Expression; >initializer : Expression +>Expression : Expression + } + interface ParameterDeclaration extends Declaration { +>ParameterDeclaration : ParameterDeclaration +>Declaration : Declaration + + dotDotDotToken?: Node; +>dotDotDotToken : Node +>Node : Node + + name: Identifier; +>name : Identifier +>Identifier : Identifier + + questionToken?: Node; +>questionToken : Node +>Node : Node + + type?: TypeNode | StringLiteralExpression; +>type : TypeNode | StringLiteralExpression +>TypeNode : TypeNode +>StringLiteralExpression : StringLiteralExpression + + initializer?: Expression; +>initializer : Expression >Expression : Expression } interface PropertyDeclaration extends Declaration, ClassElement { @@ -989,6 +1010,13 @@ declare module ts { >Declaration : Declaration >ClassElement : ClassElement + _propertyDeclarationBrand: any; +>_propertyDeclarationBrand : any + + questionToken?: Node; +>questionToken : Node +>Node : Node + type?: TypeNode; >type : TypeNode >TypeNode : TypeNode @@ -997,17 +1025,53 @@ declare module ts { >initializer : Expression >Expression : Expression } - interface ShortHandPropertyDeclaration extends Declaration { ->ShortHandPropertyDeclaration : ShortHandPropertyDeclaration + type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration; +>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration +>VariableDeclaration : VariableDeclaration +>ParameterDeclaration : ParameterDeclaration + + type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration; +>VariableOrParameterOrPropertyDeclaration : ParameterDeclaration | VariableDeclaration | PropertyDeclaration +>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration +>PropertyDeclaration : PropertyDeclaration + + interface ObjectLiteralElement extends Declaration { +>ObjectLiteralElement : ObjectLiteralElement >Declaration : Declaration + _objectLiteralBrandBrand: any; +>_objectLiteralBrandBrand : any + } + interface ShorthandPropertyAssignment extends ObjectLiteralElement { +>ShorthandPropertyAssignment : ShorthandPropertyAssignment +>ObjectLiteralElement : ObjectLiteralElement + name: Identifier; >name : Identifier >Identifier : Identifier + + questionToken?: Node; +>questionToken : Node +>Node : Node } - interface ParameterDeclaration extends VariableDeclaration { ->ParameterDeclaration : ParameterDeclaration ->VariableDeclaration : VariableDeclaration + interface PropertyAssignment extends ObjectLiteralElement { +>PropertyAssignment : PropertyAssignment +>ObjectLiteralElement : ObjectLiteralElement + + _propertyAssignmentBrand: any; +>_propertyAssignmentBrand : any + + name: DeclarationName; +>name : Identifier | LiteralExpression | ComputedPropertyName +>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName + + questionToken?: Node; +>questionToken : Node +>Node : Node + + initializer: Expression; +>initializer : Expression +>Expression : Expression } /** * Several node kinds share function-like features such as a signature, @@ -1026,6 +1090,10 @@ declare module ts { asteriskToken?: Node; >asteriskToken : Node +>Node : Node + + questionToken?: Node; +>questionToken : Node >Node : Node body?: Block | Expression; @@ -1046,10 +1114,11 @@ declare module ts { >body : Block >Block : Block } - interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement { + interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { >MethodDeclaration : MethodDeclaration >FunctionLikeDeclaration : FunctionLikeDeclaration >ClassElement : ClassElement +>ObjectLiteralElement : ObjectLiteralElement body?: Block; >body : Block @@ -1064,12 +1133,16 @@ declare module ts { >body : Block >Block : Block } - interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement { + interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { >AccessorDeclaration : AccessorDeclaration >FunctionLikeDeclaration : FunctionLikeDeclaration >ClassElement : ClassElement +>ObjectLiteralElement : ObjectLiteralElement - body?: Block; + _accessorDeclarationBrand: any; +>_accessorDeclarationBrand : any + + body: Block; >body : Block >Block : Block } @@ -1084,6 +1157,17 @@ declare module ts { interface TypeNode extends Node { >TypeNode : TypeNode >Node : Node + + _typeNodeBrand: any; +>_typeNodeBrand : any + } + interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration { +>FunctionOrConstructorTypeNode : FunctionOrConstructorTypeNode +>TypeNode : TypeNode +>SignatureDeclaration : SignatureDeclaration + + _functionOrConstructorTypeNodeBrand: any; +>_functionOrConstructorTypeNodeBrand : any } interface TypeReferenceNode extends TypeNode { >TypeReferenceNode : TypeReferenceNode @@ -1149,13 +1233,6 @@ declare module ts { type: TypeNode; >type : TypeNode >TypeNode : TypeNode - } - interface StringLiteralTypeNode extends TypeNode { ->StringLiteralTypeNode : StringLiteralTypeNode ->TypeNode : TypeNode - - text: string; ->text : string } interface Expression extends Node { >Expression : Expression @@ -1315,6 +1392,16 @@ declare module ts { text: string; >text : string + + isUnterminated?: boolean; +>isUnterminated : boolean + } + interface StringLiteralExpression extends LiteralExpression { +>StringLiteralExpression : StringLiteralExpression +>LiteralExpression : LiteralExpression + + _stringLiteralExpressionBrand: any; +>_stringLiteralExpressionBrand : any } interface TemplateExpression extends PrimaryExpression { >TemplateExpression : TemplateExpression @@ -1363,10 +1450,10 @@ declare module ts { >PrimaryExpression : PrimaryExpression >Declaration : Declaration - properties: NodeArray; ->properties : NodeArray + properties: NodeArray; +>properties : NodeArray >NodeArray : NodeArray ->Declaration : Declaration +>ObjectLiteralElement : ObjectLiteralElement } interface PropertyAccessExpression extends MemberExpression { >PropertyAccessExpression : PropertyAccessExpression @@ -1388,7 +1475,7 @@ declare module ts { >expression : LeftHandSideExpression >LeftHandSideExpression : LeftHandSideExpression - argumentExpression: Expression; + argumentExpression?: Expression; >argumentExpression : Expression >Expression : Expression } @@ -1595,12 +1682,12 @@ declare module ts { >Expression : Expression clauses: NodeArray; ->clauses : NodeArray +>clauses : NodeArray >NodeArray : NodeArray ->CaseOrDefaultClause : CaseOrDefaultClause +>CaseOrDefaultClause : CaseClause | DefaultClause } - interface CaseOrDefaultClause extends Node { ->CaseOrDefaultClause : CaseOrDefaultClause + interface CaseClause extends Node { +>CaseClause : CaseClause >Node : Node expression?: Expression; @@ -1612,6 +1699,20 @@ declare module ts { >NodeArray : NodeArray >Statement : Statement } + interface DefaultClause extends Node { +>DefaultClause : DefaultClause +>Node : Node + + statements: NodeArray; +>statements : NodeArray +>NodeArray : NodeArray +>Statement : Statement + } + type CaseOrDefaultClause = CaseClause | DefaultClause; +>CaseOrDefaultClause : CaseClause | DefaultClause +>CaseClause : CaseClause +>DefaultClause : DefaultClause + interface LabeledStatement extends Statement { >LabeledStatement : LabeledStatement >Statement : Statement @@ -1640,26 +1741,29 @@ declare module ts { >tryBlock : Block >Block : Block - catchBlock?: CatchBlock; ->catchBlock : CatchBlock ->CatchBlock : CatchBlock + catchClause?: CatchClause; +>catchClause : CatchClause +>CatchClause : CatchClause finallyBlock?: Block; >finallyBlock : Block >Block : Block } - interface CatchBlock extends Block, Declaration { ->CatchBlock : CatchBlock ->Block : Block + interface CatchClause extends Declaration { +>CatchClause : CatchClause >Declaration : Declaration - variable: Identifier; ->variable : Identifier + name: Identifier; +>name : Identifier >Identifier : Identifier type?: TypeNode; >type : TypeNode >TypeNode : TypeNode + + block: Block; +>block : Block +>Block : Block } interface ModuleElement extends Node { >ModuleElement : ModuleElement @@ -1809,13 +1913,18 @@ declare module ts { >name : Identifier >Identifier : Identifier - entityName?: EntityName; ->entityName : Identifier | QualifiedName + moduleReference: EntityName | ExternalModuleReference; +>moduleReference : Identifier | QualifiedName | ExternalModuleReference >EntityName : Identifier | QualifiedName +>ExternalModuleReference : ExternalModuleReference + } + interface ExternalModuleReference extends Node { +>ExternalModuleReference : ExternalModuleReference +>Node : Node - externalModuleName?: LiteralExpression; ->externalModuleName : LiteralExpression ->LiteralExpression : LiteralExpression + expression?: Expression; +>expression : Expression +>Expression : Expression } interface ExportAssignment extends Statement, ModuleElement { >ExportAssignment : ExportAssignment @@ -1849,6 +1958,10 @@ declare module ts { >NodeArray : NodeArray >ModuleElement : ModuleElement + endOfFileToken: Node; +>endOfFileToken : Node +>Node : Node + filename: string; >filename : string @@ -1878,8 +1991,8 @@ declare module ts { >referencedFiles : FileReference[] >FileReference : FileReference - semanticDiagnostics: Diagnostic[]; ->semanticDiagnostics : Diagnostic[] + referenceDiagnostics: Diagnostic[]; +>referenceDiagnostics : Diagnostic[] >Diagnostic : Diagnostic parseDiagnostics: Diagnostic[]; @@ -1892,6 +2005,10 @@ declare module ts { getSyntacticDiagnostics(): Diagnostic[]; >getSyntacticDiagnostics : () => Diagnostic[] +>Diagnostic : Diagnostic + + semanticDiagnostics: Diagnostic[]; +>semanticDiagnostics : Diagnostic[] >Diagnostic : Diagnostic hasNoDefaultLib: boolean; @@ -2085,23 +2202,14 @@ declare module ts { getTypeCount(): number; >getTypeCount : () => number - checkProgram(): void; ->checkProgram : () => void - emitFiles(targetSourceFile?: SourceFile): EmitResult; >emitFiles : (targetSourceFile?: SourceFile) => EmitResult >targetSourceFile : SourceFile >SourceFile : SourceFile >EmitResult : EmitResult - getParentOfSymbol(symbol: Symbol): Symbol; ->getParentOfSymbol : (symbol: Symbol) => Symbol ->symbol : Symbol ->Symbol : Symbol ->Symbol : Symbol - - getNarrowedTypeOfSymbol(symbol: Symbol, node: Node): Type; ->getNarrowedTypeOfSymbol : (symbol: Symbol, node: Node) => Type + getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type; +>getTypeOfSymbolAtLocation : (symbol: Symbol, node: Node) => Type >symbol : Symbol >Symbol : Symbol >node : Node @@ -2157,8 +2265,8 @@ declare module ts { >SymbolFlags : SymbolFlags >Symbol : Symbol - getSymbolInfo(node: Node): Symbol; ->getSymbolInfo : (node: Node) => Symbol + getSymbolAtLocation(node: Node): Symbol; +>getSymbolAtLocation : (node: Node) => Symbol >node : Node >Node : Node >Symbol : Symbol @@ -2169,8 +2277,8 @@ declare module ts { >Node : Node >Symbol : Symbol - getTypeOfNode(node: Node): Type; ->getTypeOfNode : (node: Node) => Type + getTypeAtLocation(node: Node): Type; +>getTypeAtLocation : (node: Node) => Type >node : Node >Node : Node >Type : Type @@ -2214,10 +2322,10 @@ declare module ts { >Symbol : Symbol >Symbol : Symbol - getContextualType(node: Node): Type; ->getContextualType : (node: Node) => Type ->node : Node ->Node : Node + getContextualType(node: Expression): Type; +>getContextualType : (node: Expression) => Type +>node : Expression +>Expression : Expression >Type : Type getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; @@ -2550,8 +2658,10 @@ declare module ts { >node : EnumMember >EnumMember : EnumMember - hasSemanticErrors(): boolean; ->hasSemanticErrors : () => boolean + hasSemanticErrors(sourceFile?: SourceFile): boolean; +>hasSemanticErrors : (sourceFile?: SourceFile) => boolean +>sourceFile : SourceFile +>SourceFile : SourceFile isDeclarationVisible(node: Declaration): boolean; >isDeclarationVisible : (node: Declaration) => boolean @@ -2563,10 +2673,11 @@ declare module ts { >node : FunctionLikeDeclaration >FunctionLikeDeclaration : FunctionLikeDeclaration - writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; ->writeTypeAtLocation : (location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void ->location : Node ->Node : Node + writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void; +>writeTypeOfDeclaration : (declaration: ParameterDeclaration | VariableDeclaration | AccessorDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void +>declaration : ParameterDeclaration | VariableDeclaration | AccessorDeclaration +>AccessorDeclaration : AccessorDeclaration +>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration >enclosingDeclaration : Node >Node : Node >flags : TypeFormatFlags @@ -3024,9 +3135,6 @@ declare module ts { ObjectType = 48128, >ObjectType : TypeFlags - - Structured = 65025, ->Structured : TypeFlags } interface Type { >Type : Type @@ -3358,14 +3466,6 @@ declare module ts { */ isEarly?: boolean; >isEarly : boolean - - /** - * Parse error - error produced by parser when it scanner returns a token - * that parser does not understand in its current state - * (as opposed to grammar error when parser can interpret the token but interpretation is not legal from the grammar perespective) - */ - isParseError?: boolean; ->isParseError : boolean } enum DiagnosticCategory { >DiagnosticCategory : DiagnosticCategory @@ -3456,6 +3556,9 @@ declare module ts { preserveConstEnums?: boolean; >preserveConstEnums : boolean + allowNonTsExtensions?: boolean; +>allowNonTsExtensions : boolean + [option: string]: string | number | boolean; >option : string } @@ -3924,8 +4027,10 @@ declare module ts { >message : string >SourceFile : SourceFile - getDefaultLibFilename(): string; ->getDefaultLibFilename : () => string + getDefaultLibFilename(options: CompilerOptions): string; +>getDefaultLibFilename : (options: CompilerOptions) => string +>options : CompilerOptions +>CompilerOptions : CompilerOptions getCancellationToken?(): CancellationToken; >getCancellationToken : () => CancellationToken @@ -4001,6 +4106,9 @@ declare module ts { isReservedWord(): boolean; >isReservedWord : () => boolean + isUnterminated(): boolean; +>isUnterminated : () => boolean + reScanGreaterToken(): SyntaxKind; >reScanGreaterToken : () => SyntaxKind >SyntaxKind : SyntaxKind @@ -4025,6 +4133,13 @@ declare module ts { >setTextPos : (textPos: number) => void >textPos : number + lookAhead(callback: () => T): T; +>lookAhead : (callback: () => T) => T +>T : T +>callback : () => T +>T : T +>T : T + tryScan(callback: () => T): T; >tryScan : (callback: () => T) => T >T : T @@ -4113,35 +4228,19 @@ declare module ts { >languageVersion : ScriptTarget >ScriptTarget : ScriptTarget - function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback): Scanner; ->createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback, onComment?: CommentCallback) => Scanner + function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner; +>createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback) => Scanner >languageVersion : ScriptTarget >ScriptTarget : ScriptTarget >skipTrivia : boolean >text : string >onError : ErrorCallback >ErrorCallback : ErrorCallback ->onComment : CommentCallback ->CommentCallback : CommentCallback >Scanner : Scanner } declare module ts { >ts : typeof ts - interface ReferencePathMatchResult { ->ReferencePathMatchResult : ReferencePathMatchResult - - fileReference?: FileReference; ->fileReference : FileReference ->FileReference : FileReference - - diagnostic?: DiagnosticMessage; ->diagnostic : DiagnosticMessage ->DiagnosticMessage : DiagnosticMessage - - isNoDefaultLib?: boolean; ->isNoDefaultLib : boolean - } function getNodeConstructor(kind: SyntaxKind): new () => Node; >getNodeConstructor : (kind: SyntaxKind) => new () => Node >kind : SyntaxKind @@ -4195,6 +4294,9 @@ declare module ts { declare module ts { >ts : typeof ts + var servicesVersion: string; +>servicesVersion : string + interface Node { >Node : Node @@ -4460,18 +4562,20 @@ declare module ts { >fileName : string >IScriptSnapshot : IScriptSnapshot - getLocalizedDiagnosticMessages(): any; + getLocalizedDiagnosticMessages?(): any; >getLocalizedDiagnosticMessages : () => any - getCancellationToken(): CancellationToken; + getCancellationToken?(): CancellationToken; >getCancellationToken : () => CancellationToken >CancellationToken : CancellationToken getCurrentDirectory(): string; >getCurrentDirectory : () => string - getDefaultLibFilename(): string; ->getDefaultLibFilename : () => string + getDefaultLibFilename(options: CompilerOptions): string; +>getDefaultLibFilename : (options: CompilerOptions) => string +>options : CompilerOptions +>CompilerOptions : CompilerOptions } interface LanguageService { >LanguageService : LanguageService @@ -4507,11 +4611,10 @@ declare module ts { >TextSpan : TextSpan >ClassifiedSpan : ClassifiedSpan - getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo; ->getCompletionsAtPosition : (fileName: string, position: number, isMemberCompletion: boolean) => CompletionInfo + getCompletionsAtPosition(fileName: string, position: number): CompletionInfo; +>getCompletionsAtPosition : (fileName: string, position: number) => CompletionInfo >fileName : string >position : number ->isMemberCompletion : boolean >CompletionInfo : CompletionInfo getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; @@ -5573,12 +5676,10 @@ declare module ts { static typeParameterName: string; >typeParameterName : string - } - function displayPartsToString(displayParts: SymbolDisplayPart[]): string; ->displayPartsToString : (displayParts: SymbolDisplayPart[]) => string ->displayParts : SymbolDisplayPart[] ->SymbolDisplayPart : SymbolDisplayPart + static typeAlias: string; +>typeAlias : string + } interface DisplayPartsSymbolWriter extends SymbolWriter { >DisplayPartsSymbolWriter : DisplayPartsSymbolWriter >SymbolWriter : SymbolWriter @@ -5587,6 +5688,11 @@ declare module ts { >displayParts : () => SymbolDisplayPart[] >SymbolDisplayPart : SymbolDisplayPart } + function displayPartsToString(displayParts: SymbolDisplayPart[]): string; +>displayPartsToString : (displayParts: SymbolDisplayPart[]) => string +>displayParts : SymbolDisplayPart[] +>SymbolDisplayPart : SymbolDisplayPart + function getDefaultCompilerOptions(): CompilerOptions; >getDefaultCompilerOptions : () => CompilerOptions >CompilerOptions : CompilerOptions From 905d97888345b054fff3e85ce67548729d63ce45 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 17:13:39 -0800 Subject: [PATCH 17/19] Moved createCompilerHost into parser.ts --- src/compiler/parser.ts | 71 +++++++++++++++++++ src/compiler/tsc.ts | 69 ------------------ .../reference/APISample_node_compile.js | 1 + .../reference/APISample_node_compile.types | 6 ++ .../reference/APISample_standalone_compile.js | 1 + .../APISample_standalone_compile.types | 6 ++ 6 files changed, 85 insertions(+), 69 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 5c0d15359855b..cdfb09e19ec89 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -268,6 +268,77 @@ module ts { } } + // TODO (drosen, mhegazy): Move to a more appropriate file. + export function createCompilerHost(options: CompilerOptions): CompilerHost { + var currentDirectory: string; + var existingDirectories: Map = {}; + + function getCanonicalFileName(fileName: string): string { + // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form. + // otherwise use toLowerCase as a canonical form. + return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(); + } + + // returned by CScript sys environment + var unsupportedFileEncodingErrorCode = -2147024809; + + function getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile { + try { + var text = sys.readFile(filename, options.charset); + } + catch (e) { + if (onError) { + onError(e.number === unsupportedFileEncodingErrorCode ? + createCompilerDiagnostic(Diagnostics.Unsupported_file_encoding).messageText : + e.message); + } + text = ""; + } + return text !== undefined ? createSourceFile(filename, text, languageVersion, /*version:*/ "0") : undefined; + } + + function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) { + + function directoryExists(directoryPath: string): boolean { + if (hasProperty(existingDirectories, directoryPath)) { + return true; + } + if (sys.directoryExists(directoryPath)) { + existingDirectories[directoryPath] = true; + return true; + } + return false; + } + + function ensureDirectoriesExist(directoryPath: string) { + if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) { + var parentDirectory = getDirectoryPath(directoryPath); + ensureDirectoriesExist(parentDirectory); + sys.createDirectory(directoryPath); + } + } + + try { + ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName))); + sys.writeFile(fileName, data, writeByteOrderMark); + } + catch (e) { + if (onError) onError(e.message); + } + } + + return { + getSourceFile, + getDefaultLibFilename: options => combinePaths(getDirectoryPath(normalizePath(sys.getExecutingFilePath())), options.target === ScriptTarget.ES6 ? "lib.es6.d.ts" : "lib.d.ts"), + writeFile, + getCurrentDirectory: () => currentDirectory || (currentDirectory = sys.getCurrentDirectory()), + useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames, + getCanonicalFileName, + getNewLine: () => sys.newLine + }; + } + + const enum ParsingContext { SourceElements, // Elements in source file ModuleElements, // Elements in module declaration diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index 1756f26ab48f4..5e4918d91e93a 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -133,75 +133,6 @@ module ts { reportStatisticalValue(name, (time / 1000).toFixed(2) + "s"); } - function createCompilerHost(options: CompilerOptions): CompilerHost { - var currentDirectory: string; - var existingDirectories: Map = {}; - - function getCanonicalFileName(fileName: string): string { - // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form. - // otherwise use toLowerCase as a canonical form. - return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(); - } - - // returned by CScript sys environment - var unsupportedFileEncodingErrorCode = -2147024809; - - function getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile { - try { - var text = sys.readFile(filename, options.charset); - } - catch (e) { - if (onError) { - onError(e.number === unsupportedFileEncodingErrorCode ? - getDiagnosticText(Diagnostics.Unsupported_file_encoding) : - e.message); - } - text = ""; - } - return text !== undefined ? createSourceFile(filename, text, languageVersion, /*version:*/ "0") : undefined; - } - - function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) { - - function directoryExists(directoryPath: string): boolean { - if (hasProperty(existingDirectories, directoryPath)) { - return true; - } - if (sys.directoryExists(directoryPath)) { - existingDirectories[directoryPath] = true; - return true; - } - return false; - } - - function ensureDirectoriesExist(directoryPath: string) { - if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) { - var parentDirectory = getDirectoryPath(directoryPath); - ensureDirectoriesExist(parentDirectory); - sys.createDirectory(directoryPath); - } - } - - try { - ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName))); - sys.writeFile(fileName, data, writeByteOrderMark); - } - catch (e) { - if (onError) onError(e.message); - } - } - - return { - getSourceFile, - getDefaultLibFilename: options => combinePaths(getDirectoryPath(normalizePath(sys.getExecutingFilePath())), options.target === ScriptTarget.ES6 ? "lib.es6.d.ts" : "lib.d.ts"), - writeFile, - getCurrentDirectory: () => currentDirectory || (currentDirectory = sys.getCurrentDirectory()), - useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames, - getCanonicalFileName, - getNewLine: () => sys.newLine - }; - } - export function executeCommandLine(args: string[]): void { var commandLine = parseCommandLine(args); var compilerOptions = commandLine.options; diff --git a/tests/baselines/reference/APISample_node_compile.js b/tests/baselines/reference/APISample_node_compile.js index 6807d97db8444..bcadb7c109e9b 100644 --- a/tests/baselines/reference/APISample_node_compile.js +++ b/tests/baselines/reference/APISample_node_compile.js @@ -1339,6 +1339,7 @@ declare module "typescript" { declare module "typescript" { function getNodeConstructor(kind: SyntaxKind): new () => Node; function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; + function createCompilerHost(options: CompilerOptions): CompilerHost; function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program; } diff --git a/tests/baselines/reference/APISample_node_compile.types b/tests/baselines/reference/APISample_node_compile.types index 4331fb28c72b4..389093ba3e7d2 100644 --- a/tests/baselines/reference/APISample_node_compile.types +++ b/tests/baselines/reference/APISample_node_compile.types @@ -4259,6 +4259,12 @@ declare module "typescript" { >T : T >T : T + function createCompilerHost(options: CompilerOptions): CompilerHost; +>createCompilerHost : (options: CompilerOptions) => CompilerHost +>options : CompilerOptions +>CompilerOptions : CompilerOptions +>CompilerHost : CompilerHost + function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; >createSourceFile : (filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean) => SourceFile >filename : string diff --git a/tests/baselines/reference/APISample_standalone_compile.js b/tests/baselines/reference/APISample_standalone_compile.js index fff2226f320a8..edd6c3ed49b3b 100644 --- a/tests/baselines/reference/APISample_standalone_compile.js +++ b/tests/baselines/reference/APISample_standalone_compile.js @@ -1337,6 +1337,7 @@ declare module ts { declare module ts { function getNodeConstructor(kind: SyntaxKind): new () => Node; function forEachChild(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T; + function createCompilerHost(options: CompilerOptions): CompilerHost; function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program; } diff --git a/tests/baselines/reference/APISample_standalone_compile.types b/tests/baselines/reference/APISample_standalone_compile.types index c69e655aec1a0..c4630007cba75 100644 --- a/tests/baselines/reference/APISample_standalone_compile.types +++ b/tests/baselines/reference/APISample_standalone_compile.types @@ -4262,6 +4262,12 @@ declare module ts { >T : T >T : T + function createCompilerHost(options: CompilerOptions): CompilerHost; +>createCompilerHost : (options: CompilerOptions) => CompilerHost +>options : CompilerOptions +>CompilerOptions : CompilerOptions +>CompilerHost : CompilerHost + function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile; >createSourceFile : (filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean) => SourceFile >filename : string From b6e8dd49e4bc5d74ff5c8dae171be72d82fe10b8 Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 17:34:17 -0800 Subject: [PATCH 18/19] Responded to CR feedback. --- src/compiler/parser.ts | 7 ++++--- src/compiler/utilities.ts | 6 ++++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index cdfb09e19ec89..66ed2c312fd7a 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -323,7 +323,9 @@ module ts { sys.writeFile(fileName, data, writeByteOrderMark); } catch (e) { - if (onError) onError(e.message); + if (onError) { + onError(e.message); + } } } @@ -405,14 +407,13 @@ module ts { function isEvalOrArgumentsIdentifier(node: Node): boolean { return node.kind === SyntaxKind.Identifier && - (node).text && ((node).text === "eval" || (node).text === "arguments"); } /// Should be called only on prologue directives (isPrologueDirective(node) should be true) function isUseStrictPrologueDirective(node: Node): boolean { Debug.assert(isPrologueDirective(node)); - return ((node).expression).text === "use strict"; + return getTextOfNode((node).expression) === '"use strict"'; } export function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen: boolean = false): SourceFile { diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index c3e067b7e752e..fb88b81891755 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -90,7 +90,9 @@ module ts { } export function getSourceFileOfNode(node: Node): SourceFile { - while (node && node.kind !== SyntaxKind.SourceFile) node = node.parent; + while (node && node.kind !== SyntaxKind.SourceFile) { + node = node.parent; + } return node; } @@ -161,7 +163,7 @@ module ts { node = getErrorSpanForNode(node); var file = getSourceFileOfNode(node); - var start = getFullWidth(node) === 0 ? node.pos : skipTrivia(file.text, node.pos); + var start = getTokenPosOfNode(node, file); var length = node.end - start; return createFileDiagnostic(file, start, length, message, arg0, arg1, arg2); From 0aca3b966790623b5c5e646ffeaef07d88db417a Mon Sep 17 00:00:00 2001 From: Daniel Rosenwasser Date: Wed, 10 Dec 2014 18:17:59 -0800 Subject: [PATCH 19/19] Fixed 'use strict' check. --- src/compiler/parser.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 66ed2c312fd7a..2c8a09faaa1e9 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -411,9 +411,10 @@ module ts { } /// Should be called only on prologue directives (isPrologueDirective(node) should be true) - function isUseStrictPrologueDirective(node: Node): boolean { + function isUseStrictPrologueDirective(sourceFile: SourceFile, node: Node): boolean { Debug.assert(isPrologueDirective(node)); - return getTextOfNode((node).expression) === '"use strict"'; + var nodeText = getSourceTextOfNodeFromSourceFile(sourceFile,(node).expression); + return nodeText === '"use strict"' || nodeText === "'use strict'"; } export function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen: boolean = false): SourceFile { @@ -1073,7 +1074,7 @@ module ts { // test elements only if we are not already in strict mode if (checkForStrictMode && !inStrictModeContext()) { if (isPrologueDirective(element)) { - if (isUseStrictPrologueDirective(element)) { + if (isUseStrictPrologueDirective(sourceFile, element)) { setStrictModeContext(true); checkForStrictMode = false; }