2285 lines
94 KiB
TypeScript
2285 lines
94 KiB
TypeScript
/// <reference path="types.ts"/>
|
|
/// <reference path="core.ts"/>
|
|
/// <reference path="scanner.ts"/>
|
|
/// <reference path="parser.ts"/>
|
|
|
|
module ts {
|
|
function getSourceFilePathInNewDir(newDirPath: string, sourceFile: SourceFile, program: Program, compilerHost: CompilerHost) {
|
|
var sourceFilePath = getNormalizedPathFromPathCompoments(getNormalizedPathComponents(sourceFile.filename, compilerHost.getCurrentDirectory()));
|
|
sourceFilePath = sourceFilePath.replace(program.getCommonSourceDirectory(), "");
|
|
return combinePaths(newDirPath, sourceFilePath);
|
|
}
|
|
|
|
function emitToOwnOutputFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) {
|
|
if (!(sourceFile.flags & NodeFlags.DeclarationFile)) {
|
|
if ((sourceFile.flags & NodeFlags.ExternalModule || !compilerOptions.out) && !fileExtensionIs(sourceFile.filename, ".js")) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
function getOwnEmitOutputFilePath(sourceFile: SourceFile, program: Program, extension: string) {
|
|
if (program.getCompilerOptions().outDir) {
|
|
var emitOutputFilePathWithoutExtension = getModuleNameFromFilename(getSourceFilePathInNewDir(program.getCompilerOptions().outDir, sourceFile, program, program.getCompilerHost()));
|
|
}
|
|
else {
|
|
var emitOutputFilePathWithoutExtension = getModuleNameFromFilename(sourceFile.filename);
|
|
}
|
|
|
|
return emitOutputFilePathWithoutExtension + extension;
|
|
}
|
|
|
|
function isExternalModuleOrDeclarationFile(sourceFile: SourceFile) {
|
|
return !!(sourceFile.flags & (NodeFlags.ExternalModule | NodeFlags.DeclarationFile));
|
|
}
|
|
|
|
function findConstructor(node: ClassDeclaration): ConstructorDeclaration {
|
|
return forEach(node.members, member => {
|
|
if (member.kind === SyntaxKind.Constructor && (<ConstructorDeclaration>member).body) {
|
|
return <ConstructorDeclaration>member;
|
|
}
|
|
});
|
|
}
|
|
|
|
function getAllAccessorDeclarations(node: ClassDeclaration, accessor: AccessorDeclaration) {
|
|
var firstAccessor: AccessorDeclaration;
|
|
var getAccessor: AccessorDeclaration;
|
|
var setAccessor: AccessorDeclaration;
|
|
forEach(node.members, (member: Declaration) => {
|
|
if ((member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) &&
|
|
member.name.text === accessor.name.text &&
|
|
(member.flags & NodeFlags.Static) === (accessor.flags & NodeFlags.Static)) {
|
|
if (!firstAccessor) {
|
|
firstAccessor = <AccessorDeclaration>member;
|
|
}
|
|
|
|
if (member.kind === SyntaxKind.GetAccessor && !getAccessor) {
|
|
getAccessor = <AccessorDeclaration>member;
|
|
}
|
|
|
|
if (member.kind === SyntaxKind.SetAccessor && !setAccessor) {
|
|
setAccessor = <AccessorDeclaration>member;
|
|
}
|
|
}
|
|
});
|
|
return {
|
|
firstAccessor: firstAccessor,
|
|
getAccessor: getAccessor,
|
|
setAccessor: setAccessor
|
|
};
|
|
}
|
|
|
|
export function emitFiles(resolver: EmitResolver) {
|
|
var program = resolver.getProgram();
|
|
var compilerHost = program.getCompilerHost();
|
|
var compilerOptions = program.getCompilerOptions();
|
|
var shouldEmitDeclarations = resolver.shouldEmitDeclarations();
|
|
|
|
var sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap ? [] : undefined;
|
|
forEach(program.getSourceFiles(), sourceFile => {
|
|
if (emitToOwnOutputFile(sourceFile, compilerOptions)) {
|
|
var jsFilePath = getOwnEmitOutputFilePath(sourceFile, program, ".js");
|
|
emitJavaScript(resolver, jsFilePath, sourceMapDataList, sourceFile);
|
|
if (shouldEmitDeclarations) {
|
|
emitDeclarations(resolver, jsFilePath, sourceFile);
|
|
}
|
|
}
|
|
});
|
|
if (compilerOptions.out) {
|
|
emitJavaScript(resolver, compilerOptions.out, sourceMapDataList);
|
|
if (shouldEmitDeclarations) {
|
|
emitDeclarations(resolver, compilerOptions.out);
|
|
}
|
|
}
|
|
return sourceMapDataList;
|
|
}
|
|
|
|
interface TextWriter {
|
|
write(s: string): void;
|
|
writeLiteral(s: string): void;
|
|
writeLine(): void;
|
|
increaseIndent(): void;
|
|
decreaseIndent(): void;
|
|
getTextPos(): number;
|
|
getLine(): number;
|
|
getColumn(): number;
|
|
getText(): string;
|
|
}
|
|
|
|
function createTextWriter(): TextWriter {
|
|
var output = "";
|
|
var indent = 0;
|
|
var lineStart = true;
|
|
var lineCount = 0;
|
|
var linePos = 0;
|
|
|
|
function write(s: string) {
|
|
if (s && s.length) {
|
|
if (lineStart) {
|
|
output += getIndentString(indent);
|
|
lineStart = false;
|
|
}
|
|
output += s;
|
|
}
|
|
}
|
|
|
|
function writeLiteral(s: string) {
|
|
if (s && s.length) {
|
|
write(s);
|
|
var pos = 0;
|
|
while (pos < s.length) {
|
|
switch (s.charCodeAt(pos++)) {
|
|
case CharacterCodes.carriageReturn:
|
|
if (pos < s.length && s.charCodeAt(pos) === CharacterCodes.lineFeed) {
|
|
pos++;
|
|
}
|
|
case CharacterCodes.lineFeed:
|
|
lineCount++;
|
|
linePos = output.length - s.length + pos;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function writeLine() {
|
|
if (!lineStart) {
|
|
output += sys.newLine;
|
|
lineCount++;
|
|
linePos = output.length;
|
|
lineStart = true;
|
|
}
|
|
}
|
|
|
|
return {
|
|
write: write,
|
|
writeLiteral: writeLiteral,
|
|
writeLine: writeLine,
|
|
increaseIndent: () => indent++,
|
|
decreaseIndent: () => indent--,
|
|
getTextPos: () => output.length,
|
|
getLine: () => lineCount + 1,
|
|
getColumn: () => lineStart ? indent * 4 + 1 : output.length - linePos + 1,
|
|
getText: () => output
|
|
};
|
|
}
|
|
|
|
var indentStrings: string[] = [];
|
|
|
|
function getIndentString(level: number) {
|
|
return indentStrings[level] || (indentStrings[level] = level === 0 ? "" : getIndentString(level - 1) + " ");
|
|
}
|
|
|
|
// Get source text of node in the current source file. Unlike getSourceTextOfNode this function
|
|
// doesn't walk the parent chain to find the containing source file, rather it assumes the node is
|
|
// in the source file currently being processed.
|
|
var currentSourceFile: SourceFile;
|
|
function getSourceTextOfLocalNode(node: Node): string {
|
|
var text = currentSourceFile.text;
|
|
return text.substring(skipTrivia(text, node.pos), node.end);
|
|
}
|
|
|
|
function emitJavaScript(resolver: EmitResolver, jsFilePath: string, sourceMapDataList: SourceMapData[], root?: SourceFile) {
|
|
var program = resolver.getProgram();
|
|
var compilerHost = program.getCompilerHost();
|
|
var compilerOptions = program.getCompilerOptions();
|
|
|
|
var writer = createTextWriter();
|
|
var write = writer.write;
|
|
var writeLine = writer.writeLine;
|
|
var increaseIndent = writer.increaseIndent;
|
|
var decreaseIndent = writer.decreaseIndent;
|
|
|
|
var extendsEmitted = false;
|
|
|
|
/** write emitted output to disk*/
|
|
var writeEmittedFiles = writeJavaScriptFile;
|
|
|
|
/** Emit a node */
|
|
var emit = emitNode;
|
|
|
|
/** Called just before starting emit of a node */
|
|
var emitStart = function (node: Node) { }
|
|
|
|
/** Called once the emit of the node is done */
|
|
var emitEnd = function (node: Node) { }
|
|
|
|
/** Emit the text for the given token that comes after startPos
|
|
* This by default writes the text provided with the given tokenKind
|
|
* but if optional emitFn callback is provided the text is emitted using the callback instead of default text
|
|
* @param tokenKind the kind of the token to search and emit
|
|
* @param startPos the position in the source to start searching for the token
|
|
* @param emitFn if given will be invoked to emit the text instead of actual token emit */
|
|
var emitToken = emitTokenText;
|
|
|
|
/** Called to notify start of new source file emit */
|
|
var emitNewSourceFileStart = function (node: SourceFile) { }
|
|
|
|
/** Called to before starting the lexical scopes as in function/class in the emitted code because of node
|
|
* @param scopeDeclaration node that starts the lexical scope
|
|
* @param scopeName Optional name of this scope instead of deducing one from the declaration node */
|
|
var scopeEmitStart = function (scopeDeclaration: Node, scopeName?: string) { }
|
|
|
|
/** Called after coming out of the scope */
|
|
var scopeEmitEnd = function () { }
|
|
|
|
/** Sourcemap data that will get encoded */
|
|
var sourceMapData: SourceMapData;
|
|
|
|
function initializeEmitterWithSourceMaps() {
|
|
var sourceMapDir: string; // The directory in which sourcemap will be
|
|
|
|
// Current source map file and its index in the sources list
|
|
var sourceMapSourceIndex = -1;
|
|
|
|
// Names and its index map
|
|
var sourceMapNameIndexMap: Map<number> = {};
|
|
var sourceMapNameIndices: number[] = [];
|
|
function getSourceMapNameIndex() {
|
|
return sourceMapNameIndices.length ? sourceMapNameIndices[sourceMapNameIndices.length - 1] : -1;
|
|
}
|
|
|
|
// Last recorded and encoded spans
|
|
var lastRecordedSourceMapSpan: SourceMapSpan;
|
|
var lastEncodedSourceMapSpan: SourceMapSpan = {
|
|
emittedLine: 1,
|
|
emittedColumn: 1,
|
|
sourceLine: 1,
|
|
sourceColumn: 1,
|
|
sourceIndex: 0
|
|
};
|
|
var lastEncodedNameIndex = 0;
|
|
|
|
// Encoding for sourcemap span
|
|
function encodeLastRecordedSourceMapSpan() {
|
|
if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) {
|
|
return;
|
|
}
|
|
|
|
var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn;
|
|
// Line/Comma deliminators
|
|
if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) {
|
|
// Emit comma to separate the entry
|
|
if (sourceMapData.sourceMapMappings) {
|
|
sourceMapData.sourceMapMappings += ",";
|
|
}
|
|
}
|
|
else {
|
|
// Emit line deliminators
|
|
for (var encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) {
|
|
sourceMapData.sourceMapMappings += ";";
|
|
}
|
|
prevEncodedEmittedColumn = 1;
|
|
}
|
|
|
|
// 1. Relative Column 0 based
|
|
sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn);
|
|
|
|
// 2. Relative sourceIndex
|
|
sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex);
|
|
|
|
// 3. Relative sourceLine 0 based
|
|
sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine);
|
|
|
|
// 4. Relative sourceColumn 0 based
|
|
sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn);
|
|
|
|
// 5. Relative namePosition 0 based
|
|
if (lastRecordedSourceMapSpan.nameIndex >= 0) {
|
|
sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex);
|
|
lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex;
|
|
}
|
|
|
|
lastEncodedSourceMapSpan = lastRecordedSourceMapSpan;
|
|
sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan);
|
|
|
|
function base64VLQFormatEncode(inValue: number) {
|
|
function base64FormatEncode(inValue: number) {
|
|
if (inValue < 64) {
|
|
return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(inValue);
|
|
}
|
|
throw TypeError(inValue + ": not a 64 based value");
|
|
}
|
|
|
|
// Add a new least significant bit that has the sign of the value.
|
|
// if negative number the least significant bit that gets added to the number has value 1
|
|
// else least significant bit value that gets added is 0
|
|
// eg. -1 changes to binary : 01 [1] => 3
|
|
// +1 changes to binary : 01 [0] => 2
|
|
if (inValue < 0) {
|
|
inValue = ((-inValue) << 1) + 1;
|
|
}
|
|
else {
|
|
inValue = inValue << 1;
|
|
}
|
|
|
|
// Encode 5 bits at a time starting from least significant bits
|
|
var encodedStr = "";
|
|
do {
|
|
var currentDigit = inValue & 31; // 11111
|
|
inValue = inValue >> 5;
|
|
if (inValue > 0) {
|
|
// There are still more digits to decode, set the msb (6th bit)
|
|
currentDigit = currentDigit | 32;
|
|
}
|
|
encodedStr = encodedStr + base64FormatEncode(currentDigit);
|
|
} while (inValue > 0);
|
|
|
|
return encodedStr;
|
|
}
|
|
}
|
|
|
|
function recordSourceMapSpan(pos: number) {
|
|
var sourceLinePos = currentSourceFile.getLineAndCharacterFromPosition(pos);
|
|
var emittedLine = writer.getLine();
|
|
var emittedColumn = writer.getColumn();
|
|
|
|
// If this location wasnt recorded or the location in source is going backwards, record the span
|
|
if (!lastRecordedSourceMapSpan ||
|
|
lastRecordedSourceMapSpan.emittedLine != emittedLine ||
|
|
lastRecordedSourceMapSpan.emittedColumn != emittedColumn ||
|
|
lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line ||
|
|
(lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)) {
|
|
// Encode the last recordedSpan before assigning new
|
|
encodeLastRecordedSourceMapSpan();
|
|
|
|
// New span
|
|
lastRecordedSourceMapSpan = {
|
|
emittedLine: emittedLine,
|
|
emittedColumn: emittedColumn,
|
|
sourceLine: sourceLinePos.line,
|
|
sourceColumn: sourceLinePos.character,
|
|
nameIndex: getSourceMapNameIndex(),
|
|
sourceIndex: sourceMapSourceIndex
|
|
};
|
|
}
|
|
else {
|
|
// Take the new pos instead since there is no change in emittedLine and column since last location
|
|
lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line;
|
|
lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character;
|
|
}
|
|
}
|
|
|
|
function recordEmitNodeStartSpan(node: Node) {
|
|
// Get the token pos after skipping to the token (ignoring the leading trivia)
|
|
recordSourceMapSpan(ts.getTokenPosOfNode(node));
|
|
}
|
|
|
|
function recordEmitNodeEndSpan(node: Node) {
|
|
recordSourceMapSpan(node.end);
|
|
}
|
|
|
|
function writeTextWithSpanRecord(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {
|
|
var tokenStartPos = ts.skipTrivia(currentSourceFile.text, startPos);
|
|
recordSourceMapSpan(tokenStartPos);
|
|
var tokenEndPos = emitTokenText(tokenKind, tokenStartPos, emitFn);
|
|
recordSourceMapSpan(tokenEndPos);
|
|
return tokenEndPos;
|
|
}
|
|
|
|
function recordNewSourceFileStart(node: SourceFile) {
|
|
// Add the the file to tsFilePaths
|
|
// If sourceroot option: Use the relative path corresponding to the common directory path
|
|
// otherwise source locations relative to map file location
|
|
var sourcesDirectoryPath = compilerOptions.sourceRoot ? program.getCommonSourceDirectory() : sourceMapDir;
|
|
|
|
sourceMapData.sourceMapSources.push(getRelativePathToDirectoryOrUrl(sourcesDirectoryPath,
|
|
node.filename,
|
|
compilerHost.getCurrentDirectory(),
|
|
/*isAbsolutePathAnUrl*/ true));
|
|
sourceMapSourceIndex = sourceMapData.sourceMapSources.length - 1;
|
|
|
|
// The one that can be used from program to get the actual source file
|
|
sourceMapData.inputSourceFileNames.push(node.filename);
|
|
}
|
|
|
|
function recordScopeNameOfNode(node: Node, scopeName?: string) {
|
|
function recordScopeNameIndex(scopeNameIndex: number) {
|
|
sourceMapNameIndices.push(scopeNameIndex);
|
|
}
|
|
|
|
function recordScopeNameStart(scopeName: string) {
|
|
var scopeNameIndex = -1;
|
|
if (scopeName) {
|
|
var parentIndex = getSourceMapNameIndex();
|
|
if (parentIndex !== -1) {
|
|
scopeName = sourceMapData.sourceMapNames[parentIndex] + "." + scopeName;
|
|
}
|
|
|
|
scopeNameIndex = getProperty(sourceMapNameIndexMap, scopeName);
|
|
if (scopeNameIndex === undefined) {
|
|
scopeNameIndex = sourceMapData.sourceMapNames.length;
|
|
sourceMapData.sourceMapNames.push(scopeName);
|
|
sourceMapNameIndexMap[scopeName] = scopeNameIndex;
|
|
}
|
|
}
|
|
recordScopeNameIndex(scopeNameIndex);
|
|
}
|
|
|
|
if (scopeName) {
|
|
// The scope was already given a name use it
|
|
recordScopeNameStart(scopeName);
|
|
}
|
|
else if (node.kind === SyntaxKind.FunctionDeclaration ||
|
|
node.kind === SyntaxKind.FunctionExpression ||
|
|
node.kind === SyntaxKind.Method ||
|
|
node.kind === SyntaxKind.GetAccessor ||
|
|
node.kind === SyntaxKind.SetAccessor ||
|
|
node.kind === SyntaxKind.ModuleDeclaration ||
|
|
node.kind === SyntaxKind.ClassDeclaration ||
|
|
node.kind === SyntaxKind.EnumDeclaration) {
|
|
// Declaration and has associated name use it
|
|
if ((<Declaration>node).name) {
|
|
scopeName = (<Declaration>node).name.text;
|
|
}
|
|
recordScopeNameStart(scopeName);
|
|
}
|
|
else {
|
|
// Block just use the name from upper level scope
|
|
recordScopeNameIndex(getSourceMapNameIndex());
|
|
}
|
|
}
|
|
|
|
function recordScopeNameEnd() {
|
|
sourceMapNameIndices.pop();
|
|
};
|
|
|
|
function writeJavaScriptAndSourceMapFile(emitOutput: string) {
|
|
// Write source map file
|
|
encodeLastRecordedSourceMapSpan();
|
|
compilerHost.writeFile(sourceMapData.sourceMapFilePath, JSON.stringify({
|
|
version: 3,
|
|
file: sourceMapData.sourceMapFile,
|
|
sourceRoot: sourceMapData.sourceMapSourceRoot,
|
|
sources: sourceMapData.sourceMapSources,
|
|
names: sourceMapData.sourceMapNames,
|
|
mappings: sourceMapData.sourceMapMappings
|
|
}));
|
|
sourceMapDataList.push(sourceMapData);
|
|
|
|
// Write sourcemap url to the js file and write the js file
|
|
writeJavaScriptFile(emitOutput + "//# sourceMappingURL=" + sourceMapData.jsSourceMappingURL);
|
|
}
|
|
|
|
// Initialize source map data
|
|
var sourceMapJsFile = getBaseFilename(normalizeSlashes(jsFilePath));
|
|
sourceMapData = {
|
|
sourceMapFilePath: jsFilePath + ".map",
|
|
jsSourceMappingURL: sourceMapJsFile + ".map",
|
|
sourceMapFile: sourceMapJsFile,
|
|
sourceMapSourceRoot: compilerOptions.sourceRoot || "",
|
|
sourceMapSources: [],
|
|
inputSourceFileNames: [],
|
|
sourceMapNames: [],
|
|
sourceMapMappings: "",
|
|
sourceMapDecodedMappings: []
|
|
};
|
|
|
|
// Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the
|
|
// relative paths of the sources list in the sourcemap
|
|
sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot);
|
|
if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== CharacterCodes.slash) {
|
|
sourceMapData.sourceMapSourceRoot += directorySeparator;
|
|
}
|
|
|
|
if (compilerOptions.mapRoot) {
|
|
sourceMapDir = normalizeSlashes(compilerOptions.mapRoot);
|
|
if (root) { // emitting single module file
|
|
// For modules or multiple emit files the mapRoot will have directory structure like the sources
|
|
// So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map
|
|
sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceMapDir, root, program, compilerHost));
|
|
}
|
|
|
|
if (!isRootedDiskPath(sourceMapDir) && !isUrl(sourceMapDir)) {
|
|
// The relative paths are relative to the common directory
|
|
sourceMapDir = combinePaths(program.getCommonSourceDirectory(), sourceMapDir);
|
|
sourceMapData.jsSourceMappingURL = getRelativePathToDirectoryOrUrl(
|
|
getDirectoryPath(normalizePath(jsFilePath)), // get the relative sourceMapDir path based on jsFilePath
|
|
combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), // this is where user expects to see sourceMap
|
|
compilerHost.getCurrentDirectory(),
|
|
/*isAbsolutePathAnUrl*/ true);
|
|
}
|
|
else {
|
|
sourceMapData.jsSourceMappingURL = combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL);
|
|
}
|
|
}
|
|
else {
|
|
sourceMapDir = getDirectoryPath(normalizePath(jsFilePath));
|
|
}
|
|
|
|
function emitNodeWithMap(node: Node) {
|
|
if (node) {
|
|
if (node.kind != SyntaxKind.SourceFile) {
|
|
recordEmitNodeStartSpan(node);
|
|
emitNode(node);
|
|
recordEmitNodeEndSpan(node);
|
|
}
|
|
else {
|
|
recordNewSourceFileStart(<SourceFile>node);
|
|
emitNode(node);
|
|
}
|
|
}
|
|
}
|
|
|
|
writeEmittedFiles = writeJavaScriptAndSourceMapFile;
|
|
emit = emitNodeWithMap;
|
|
emitStart = recordEmitNodeStartSpan;
|
|
emitEnd = recordEmitNodeEndSpan;
|
|
emitToken = writeTextWithSpanRecord;
|
|
emitNewSourceFileStart = recordNewSourceFileStart;
|
|
scopeEmitStart = recordScopeNameOfNode;
|
|
scopeEmitEnd = recordScopeNameEnd;
|
|
}
|
|
|
|
function writeJavaScriptFile(emitOutput: string) {
|
|
compilerHost.writeFile(jsFilePath, emitOutput);
|
|
}
|
|
|
|
function emitTokenText(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {
|
|
var tokenString = tokenToString(tokenKind);
|
|
if (emitFn) {
|
|
emitFn();
|
|
}
|
|
else {
|
|
write(tokenString);
|
|
}
|
|
return startPos + tokenString.length;
|
|
}
|
|
|
|
function emitOptional(prefix: string, node: Node) {
|
|
if (node) {
|
|
write(prefix);
|
|
emit(node);
|
|
}
|
|
}
|
|
|
|
function emitCommaList(nodes: Node[], count?: number) {
|
|
if (!(count >= 0)) count = nodes.length;
|
|
if (nodes) {
|
|
for (var i = 0; i < count; i++) {
|
|
if (i) write(", ");
|
|
emit(nodes[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function emitMultiLineList(nodes: Node[]) {
|
|
if (nodes) {
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
if (i) write(",");
|
|
writeLine();
|
|
emit(nodes[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function emitLines(nodes: Node[]) {
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
writeLine();
|
|
emit(nodes[i]);
|
|
}
|
|
}
|
|
|
|
function emitLiteral(node: LiteralExpression) {
|
|
var text = getSourceTextOfLocalNode(node);
|
|
if (node.kind === SyntaxKind.StringLiteral && compilerOptions.sourceMap) {
|
|
writer.writeLiteral(text);
|
|
}
|
|
else {
|
|
write(text);
|
|
}
|
|
}
|
|
|
|
// This function specifically handles numeric/string literals for enum and accessor 'identifiers'.
|
|
// In a sense, it does not actually emit identifiers as much as it declares a name for a specific property.
|
|
function emitQuotedIdentifier(node: Identifier) {
|
|
if (node.kind === SyntaxKind.StringLiteral) {
|
|
emitLiteral(node);
|
|
}
|
|
else {
|
|
write("\"");
|
|
|
|
if (node.kind === SyntaxKind.NumericLiteral) {
|
|
write(node.text);
|
|
}
|
|
else {
|
|
write(getSourceTextOfLocalNode(node));
|
|
}
|
|
|
|
write("\"");
|
|
}
|
|
}
|
|
|
|
function isNonExpressionIdentifier(node: Identifier) {
|
|
var parent = node.parent;
|
|
switch (parent.kind) {
|
|
case SyntaxKind.Parameter:
|
|
case SyntaxKind.VariableDeclaration:
|
|
case SyntaxKind.Property:
|
|
case SyntaxKind.PropertyAssignment:
|
|
case SyntaxKind.EnumMember:
|
|
case SyntaxKind.Method:
|
|
case SyntaxKind.FunctionDeclaration:
|
|
case SyntaxKind.GetAccessor:
|
|
case SyntaxKind.SetAccessor:
|
|
case SyntaxKind.FunctionExpression:
|
|
case SyntaxKind.ClassDeclaration:
|
|
case SyntaxKind.InterfaceDeclaration:
|
|
case SyntaxKind.EnumDeclaration:
|
|
case SyntaxKind.ModuleDeclaration:
|
|
case SyntaxKind.ImportDeclaration:
|
|
return (<Declaration>parent).name === node;
|
|
case SyntaxKind.BreakStatement:
|
|
case SyntaxKind.ContinueStatement:
|
|
case SyntaxKind.ExportAssignment:
|
|
return false;
|
|
case SyntaxKind.LabelledStatement:
|
|
return (<LabelledStatement>node.parent).label === node;
|
|
case SyntaxKind.CatchBlock:
|
|
return (<CatchBlock>node.parent).variable === node;
|
|
}
|
|
}
|
|
|
|
function emitIdentifier(node: Identifier) {
|
|
if (!isNonExpressionIdentifier(node)) {
|
|
var prefix = resolver.getExpressionNamePrefix(node);
|
|
if (prefix) {
|
|
write(prefix);
|
|
write(".");
|
|
}
|
|
}
|
|
write(getSourceTextOfLocalNode(node));
|
|
}
|
|
|
|
function emitThis(node: Node) {
|
|
if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.LexicalThis) {
|
|
write("_this");
|
|
}
|
|
else {
|
|
write("this");
|
|
}
|
|
}
|
|
|
|
function emitSuper(node: Node) {
|
|
var flags = resolver.getNodeCheckFlags(node);
|
|
if (flags & NodeCheckFlags.SuperInstance) {
|
|
write("_super.prototype");
|
|
}
|
|
else if (flags & NodeCheckFlags.SuperStatic) {
|
|
write("_super");
|
|
}
|
|
else {
|
|
write("super");
|
|
}
|
|
}
|
|
|
|
function emitArrayLiteral(node: ArrayLiteral) {
|
|
if (node.flags & NodeFlags.MultiLine) {
|
|
write("[");
|
|
increaseIndent();
|
|
emitMultiLineList(node.elements);
|
|
decreaseIndent();
|
|
writeLine();
|
|
write("]");
|
|
}
|
|
else {
|
|
write("[");
|
|
emitCommaList(node.elements);
|
|
write("]");
|
|
}
|
|
}
|
|
|
|
function emitObjectLiteral(node: ObjectLiteral) {
|
|
if (!node.properties.length) {
|
|
write("{}");
|
|
}
|
|
else if (node.flags & NodeFlags.MultiLine) {
|
|
write("{");
|
|
increaseIndent();
|
|
emitMultiLineList(node.properties);
|
|
decreaseIndent();
|
|
writeLine();
|
|
write("}");
|
|
}
|
|
else {
|
|
write("{ ");
|
|
emitCommaList(node.properties);
|
|
write(" }");
|
|
}
|
|
}
|
|
|
|
function emitPropertyAssignment(node: PropertyDeclaration) {
|
|
emit(node.name);
|
|
write(": ");
|
|
emit(node.initializer);
|
|
}
|
|
|
|
function emitPropertyAccess(node: PropertyAccess) {
|
|
var text = resolver.getPropertyAccessSubstitution(node);
|
|
if (text) {
|
|
write(text);
|
|
return;
|
|
}
|
|
emit(node.left);
|
|
write(".");
|
|
emit(node.right);
|
|
}
|
|
|
|
function emitIndexedAccess(node: IndexedAccess) {
|
|
emit(node.object);
|
|
write("[");
|
|
emit(node.index);
|
|
write("]");
|
|
}
|
|
|
|
function emitCallExpression(node: CallExpression) {
|
|
var superCall = false;
|
|
if (node.func.kind === SyntaxKind.SuperKeyword) {
|
|
write("_super");
|
|
superCall = true;
|
|
}
|
|
else {
|
|
emit(node.func);
|
|
superCall = node.func.kind === SyntaxKind.PropertyAccess && (<PropertyAccess>node.func).left.kind === SyntaxKind.SuperKeyword;
|
|
}
|
|
if (superCall) {
|
|
write(".call(");
|
|
emitThis(node.func);
|
|
if (node.arguments.length) {
|
|
write(", ");
|
|
emitCommaList(node.arguments);
|
|
}
|
|
write(")");
|
|
}
|
|
else {
|
|
write("(");
|
|
emitCommaList(node.arguments);
|
|
write(")");
|
|
}
|
|
}
|
|
|
|
function emitNewExpression(node: NewExpression) {
|
|
write("new ");
|
|
emit(node.func);
|
|
if (node.arguments) {
|
|
write("(");
|
|
emitCommaList(node.arguments);
|
|
write(")");
|
|
}
|
|
}
|
|
|
|
function emitParenExpression(node: ParenExpression) {
|
|
if (node.expression.kind === SyntaxKind.TypeAssertion) {
|
|
var operand = (<TypeAssertion>node.expression).operand;
|
|
|
|
// Make sure we consider all nested cast expressions, e.g.:
|
|
// (<any><number><any>-A).x;
|
|
while (operand.kind == SyntaxKind.TypeAssertion) {
|
|
operand = (<TypeAssertion>operand).operand;
|
|
}
|
|
|
|
// We have an expression of the form: (<Type>SubExpr)
|
|
// Emitting this as (SubExpr) is really not desirable. We would like to emit the subexpr as is.
|
|
// Omitting the parentheses, however, could cause change in the semantics of the generated
|
|
// code if the casted expression has a lower precedence than the rest of the expression, e.g.:
|
|
// (<any>new A).foo should be emitted as (new A).foo and not new A.foo
|
|
// (<any>typeof A).toString() should be emitted as (typeof A).toString() and not typeof A.toString()
|
|
// new (<any>A()) should be emitted as new (A()) and not new A()
|
|
// (<any>function foo() { })() should be emitted as an IIF (function foo(){})() and not declaration function foo(){} ()
|
|
if (operand.kind !== SyntaxKind.PrefixOperator && operand.kind !== SyntaxKind.PostfixOperator && operand.kind !== SyntaxKind.NewExpression &&
|
|
!(operand.kind === SyntaxKind.CallExpression && node.parent.kind === SyntaxKind.NewExpression) &&
|
|
!(operand.kind === SyntaxKind.FunctionExpression && node.parent.kind === SyntaxKind.CallExpression)) {
|
|
emit(operand);
|
|
return;
|
|
}
|
|
}
|
|
write("(");
|
|
emit(node.expression);
|
|
write(")");
|
|
}
|
|
|
|
function emitUnaryExpression(node: UnaryExpression) {
|
|
if (node.kind === SyntaxKind.PrefixOperator) {
|
|
write(tokenToString(node.operator));
|
|
}
|
|
// In some cases, we need to emit a space between the operator and the operand. One obvious case
|
|
// is when the operator is an identifer, like delete or typeof. We also need to do this for plus
|
|
// and minus expressions in certain cases. Specifically, consider the following two cases (parens
|
|
// are just for clarity of exposition, and not part of the source code):
|
|
//
|
|
// (+(+1))
|
|
// (+(++1))
|
|
//
|
|
// We need to emit a space in both cases. In the first case, the absence of a space will make
|
|
// the resulting expression a prefix increment operation. And in the second, it will make the resulting
|
|
// expression a prefix increment whose operand is a plus expression - (++(+x))
|
|
// The same is true of minus of course.
|
|
if (node.operator >= SyntaxKind.Identifier) {
|
|
write(" ");
|
|
}
|
|
else if (node.kind === SyntaxKind.PrefixOperator && node.operand.kind === SyntaxKind.PrefixOperator) {
|
|
var operand = <UnaryExpression>node.operand;
|
|
if (node.operator === SyntaxKind.PlusToken && (operand.operator === SyntaxKind.PlusToken || operand.operator === SyntaxKind.PlusPlusToken)) {
|
|
write(" ");
|
|
}
|
|
else if (node.operator === SyntaxKind.MinusToken && (operand.operator === SyntaxKind.MinusToken || operand.operator === SyntaxKind.MinusMinusToken)) {
|
|
write(" ");
|
|
}
|
|
}
|
|
emit(node.operand);
|
|
if (node.kind === SyntaxKind.PostfixOperator) {
|
|
write(tokenToString(node.operator));
|
|
}
|
|
}
|
|
|
|
function emitBinaryExpression(node: BinaryExpression) {
|
|
emit(node.left);
|
|
if (node.operator !== SyntaxKind.CommaToken) write(" ");
|
|
write(tokenToString(node.operator));
|
|
write(" ");
|
|
emit(node.right);
|
|
}
|
|
|
|
function emitConditionalExpression(node: ConditionalExpression) {
|
|
emit(node.condition);
|
|
write(" ? ");
|
|
emit(node.whenTrue);
|
|
write(" : ");
|
|
emit(node.whenFalse);
|
|
}
|
|
|
|
function emitBlock(node: Block) {
|
|
emitToken(SyntaxKind.OpenBraceToken, node.pos);
|
|
increaseIndent();
|
|
scopeEmitStart(node.parent);
|
|
if (node.kind === SyntaxKind.ModuleBlock) {
|
|
Debug.assert(node.parent.kind === SyntaxKind.ModuleDeclaration);
|
|
emitCaptureThisForNodeIfNecessary(node.parent);
|
|
}
|
|
emitLines(node.statements);
|
|
decreaseIndent();
|
|
writeLine();
|
|
emitToken(SyntaxKind.CloseBraceToken, node.statements.end);
|
|
scopeEmitEnd();
|
|
}
|
|
|
|
function emitEmbeddedStatement(node: Node) {
|
|
if (node.kind === SyntaxKind.Block) {
|
|
write(" ");
|
|
emit(<Block>node);
|
|
}
|
|
else {
|
|
increaseIndent();
|
|
writeLine();
|
|
emit(node);
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
|
|
function emitExpressionStatement(node: ExpressionStatement) {
|
|
var isArrowExpression = node.expression.kind === SyntaxKind.ArrowFunction;
|
|
if (isArrowExpression) write("(");
|
|
emit(node.expression);
|
|
if (isArrowExpression) write(")");
|
|
write(";");
|
|
}
|
|
|
|
function emitIfStatement(node: IfStatement) {
|
|
var endPos = emitToken(SyntaxKind.IfKeyword, node.pos);
|
|
write(" ");
|
|
endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
|
|
emit(node.expression);
|
|
emitToken(SyntaxKind.CloseParenToken, node.expression.end);
|
|
emitEmbeddedStatement(node.thenStatement);
|
|
if (node.elseStatement) {
|
|
writeLine();
|
|
emitToken(SyntaxKind.ElseKeyword, node.thenStatement.end);
|
|
if (node.elseStatement.kind === SyntaxKind.IfStatement) {
|
|
write(" ");
|
|
emit(node.elseStatement);
|
|
}
|
|
else {
|
|
emitEmbeddedStatement(node.elseStatement);
|
|
}
|
|
}
|
|
}
|
|
|
|
function emitDoStatement(node: DoStatement) {
|
|
write("do");
|
|
emitEmbeddedStatement(node.statement);
|
|
if (node.statement.kind === SyntaxKind.Block) {
|
|
write(" ");
|
|
}
|
|
else {
|
|
writeLine();
|
|
}
|
|
write("while (");
|
|
emit(node.expression);
|
|
write(");");
|
|
}
|
|
|
|
function emitWhileStatement(node: WhileStatement) {
|
|
write("while (");
|
|
emit(node.expression);
|
|
write(")");
|
|
emitEmbeddedStatement(node.statement);
|
|
}
|
|
|
|
function emitForStatement(node: ForStatement) {
|
|
var endPos = emitToken(SyntaxKind.ForKeyword, node.pos);
|
|
write(" ");
|
|
endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
|
|
if (node.declarations) {
|
|
emitToken(SyntaxKind.VarKeyword, endPos);
|
|
write(" ");
|
|
emitCommaList(node.declarations);
|
|
}
|
|
if (node.initializer) {
|
|
emit(node.initializer);
|
|
}
|
|
write(";");
|
|
emitOptional(" ", node.condition);
|
|
write(";");
|
|
emitOptional(" ", node.iterator);
|
|
write(")");
|
|
emitEmbeddedStatement(node.statement);
|
|
}
|
|
|
|
function emitForInStatement(node: ForInStatement) {
|
|
var endPos = emitToken(SyntaxKind.ForKeyword, node.pos);
|
|
write(" ");
|
|
endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
|
|
if (node.declaration) {
|
|
emitToken(SyntaxKind.VarKeyword, endPos);
|
|
write(" ");
|
|
emit(node.declaration);
|
|
}
|
|
else {
|
|
emit(node.variable);
|
|
}
|
|
write(" in ");
|
|
emit(node.expression);
|
|
emitToken(SyntaxKind.CloseParenToken, node.expression.end);
|
|
emitEmbeddedStatement(node.statement);
|
|
}
|
|
|
|
function emitBreakOrContinueStatement(node: BreakOrContinueStatement) {
|
|
emitToken(node.kind === SyntaxKind.BreakStatement ? SyntaxKind.BreakKeyword : SyntaxKind.ContinueKeyword, node.pos);
|
|
emitOptional(" ", node.label);
|
|
write(";");
|
|
}
|
|
|
|
function emitReturnStatement(node: ReturnStatement) {
|
|
emitToken(SyntaxKind.ReturnKeyword, node.pos);
|
|
emitOptional(" ", node.expression);
|
|
write(";");
|
|
}
|
|
|
|
function emitWithStatement(node: WhileStatement) {
|
|
write("with (");
|
|
emit(node.expression);
|
|
write(")");
|
|
emitEmbeddedStatement(node.statement);
|
|
}
|
|
|
|
function emitSwitchStatement(node: SwitchStatement) {
|
|
var endPos = emitToken(SyntaxKind.SwitchKeyword, node.pos);
|
|
write(" ");
|
|
emitToken(SyntaxKind.OpenParenToken, endPos);
|
|
emit(node.expression);
|
|
endPos = emitToken(SyntaxKind.CloseParenToken, node.expression.end);
|
|
write(" ");
|
|
emitToken(SyntaxKind.OpenBraceToken, endPos);
|
|
increaseIndent();
|
|
emitLines(node.clauses);
|
|
decreaseIndent();
|
|
writeLine();
|
|
emitToken(SyntaxKind.CloseBraceToken, node.clauses.end);
|
|
}
|
|
|
|
function emitCaseOrDefaultClause(node: CaseOrDefaultClause) {
|
|
if (node.kind === SyntaxKind.CaseClause) {
|
|
write("case ");
|
|
emit(node.expression);
|
|
write(":");
|
|
}
|
|
else {
|
|
write("default:");
|
|
}
|
|
increaseIndent();
|
|
emitLines(node.statements);
|
|
decreaseIndent();
|
|
}
|
|
|
|
function emitThrowStatement(node: ThrowStatement) {
|
|
write("throw ");
|
|
emit(node.expression);
|
|
write(";");
|
|
}
|
|
|
|
function emitTryStatement(node: TryStatement) {
|
|
write("try ");
|
|
emit(node.tryBlock);
|
|
emit(node.catchBlock);
|
|
if (node.finallyBlock) {
|
|
writeLine();
|
|
write("finally ");
|
|
emit(node.finallyBlock);
|
|
}
|
|
}
|
|
|
|
function emitCatchBlock(node: CatchBlock) {
|
|
writeLine();
|
|
var endPos = emitToken(SyntaxKind.CatchKeyword, node.pos);
|
|
write(" ");
|
|
emitToken(SyntaxKind.OpenParenToken, endPos);
|
|
emit(node.variable);
|
|
emitToken(SyntaxKind.CloseParenToken, node.variable.end);
|
|
write(" ");
|
|
emitBlock(node);
|
|
}
|
|
|
|
function emitDebuggerStatement(node: Node) {
|
|
emitToken(SyntaxKind.DebuggerKeyword, node.pos);
|
|
write(";");
|
|
}
|
|
|
|
function emitLabelledStatement(node: LabelledStatement) {
|
|
emit(node.label);
|
|
write(": ");
|
|
emit(node.statement);
|
|
}
|
|
|
|
function getContainingModule(node: Node): ModuleDeclaration {
|
|
do {
|
|
node = node.parent;
|
|
} while (node && node.kind !== SyntaxKind.ModuleDeclaration);
|
|
return <ModuleDeclaration>node;
|
|
}
|
|
|
|
function emitModuleMemberName(node: Declaration) {
|
|
emitStart(node.name);
|
|
if (node.flags & NodeFlags.Export) {
|
|
var container = getContainingModule(node);
|
|
write(container ? resolver.getModuleObjectName(container) : "exports");
|
|
write(".");
|
|
}
|
|
emitNode(node.name);
|
|
emitEnd(node.name);
|
|
}
|
|
|
|
function emitVariableDeclaration(node: VariableDeclaration) {
|
|
emitModuleMemberName(node);
|
|
emitOptional(" = ", node.initializer);
|
|
}
|
|
|
|
function emitVariableStatement(node: VariableStatement) {
|
|
if (!(node.flags & NodeFlags.Export)) write("var ");
|
|
emitCommaList(node.declarations);
|
|
write(";");
|
|
}
|
|
|
|
function emitParameter(node: ParameterDeclaration) {
|
|
emit(node.name);
|
|
}
|
|
|
|
function emitDefaultValueAssignments(node: FunctionDeclaration) {
|
|
forEach(node.parameters, param => {
|
|
if (param.initializer) {
|
|
writeLine();
|
|
emitStart(param);
|
|
write("if (");
|
|
emitNode(param.name);
|
|
write(" === void 0)");
|
|
emitEnd(param);
|
|
write(" { ");
|
|
emitStart(param);
|
|
emitNode(param.name);
|
|
write(" = ");
|
|
emitNode(param.initializer);
|
|
emitEnd(param);
|
|
write("; }");
|
|
}
|
|
});
|
|
}
|
|
|
|
function emitRestParameter(node: FunctionDeclaration) {
|
|
if (hasRestParameters(node)) {
|
|
var restIndex = node.parameters.length - 1;
|
|
var restParam = node.parameters[restIndex];
|
|
writeLine();
|
|
emitStart(restParam);
|
|
write("var ");
|
|
emitNode(restParam.name);
|
|
write(" = [];");
|
|
emitEnd(restParam);
|
|
writeLine();
|
|
write("for (");
|
|
emitStart(restParam);
|
|
write("var _i = " + restIndex + ";");
|
|
emitEnd(restParam);
|
|
write(" ");
|
|
emitStart(restParam);
|
|
write("_i < arguments.length;");
|
|
emitEnd(restParam);
|
|
write(" ");
|
|
emitStart(restParam);
|
|
write("_i++");
|
|
emitEnd(restParam);
|
|
write(") {");
|
|
increaseIndent();
|
|
writeLine();
|
|
emitStart(restParam);
|
|
emitNode(restParam.name);
|
|
write("[_i - " + restIndex + "] = arguments[_i];");
|
|
emitEnd(restParam);
|
|
decreaseIndent();
|
|
writeLine();
|
|
write("}");
|
|
}
|
|
}
|
|
|
|
function emitAccessor(node: AccessorDeclaration) {
|
|
write(node.kind === SyntaxKind.GetAccessor ? "get " : "set ");
|
|
emit(node.name);
|
|
emitSignatureAndBody(node);
|
|
}
|
|
|
|
function emitFunctionDeclaration(node: FunctionDeclaration) {
|
|
if (!node.body) return;
|
|
write("function ");
|
|
if (node.kind === SyntaxKind.FunctionDeclaration || (node.kind === SyntaxKind.FunctionExpression && node.name)) {
|
|
emit(node.name);
|
|
}
|
|
emitSignatureAndBody(node);
|
|
}
|
|
|
|
function emitCaptureThisForNodeIfNecessary(node: Node): void {
|
|
if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureThis) {
|
|
writeLine();
|
|
emitStart(node);
|
|
write("var _this = this;");
|
|
emitEnd(node);
|
|
}
|
|
}
|
|
|
|
function emitSignatureAndBody(node: FunctionDeclaration) {
|
|
write("(");
|
|
emitCommaList(node.parameters, node.parameters.length - (hasRestParameters(node) ? 1 : 0));
|
|
write(") {");
|
|
scopeEmitStart(node);
|
|
increaseIndent();
|
|
var outPos = writer.getTextPos();
|
|
emitCaptureThisForNodeIfNecessary(node);
|
|
emitDefaultValueAssignments(node);
|
|
emitRestParameter(node);
|
|
if (node.body.kind !== SyntaxKind.FunctionBlock && outPos === writer.getTextPos()) {
|
|
decreaseIndent();
|
|
write(" ");
|
|
emitStart(node.body);
|
|
write("return ");
|
|
emitNode(node.body);
|
|
emitEnd(node.body);
|
|
write("; ");
|
|
emitStart(node.body);
|
|
write("}");
|
|
emitEnd(node.body);
|
|
}
|
|
else {
|
|
if (node.body.kind === SyntaxKind.FunctionBlock) {
|
|
emitLines((<Block>node.body).statements);
|
|
}
|
|
else {
|
|
writeLine();
|
|
write("return ");
|
|
emit(node.body);
|
|
write(";");
|
|
}
|
|
decreaseIndent();
|
|
writeLine();
|
|
if (node.body.kind === SyntaxKind.FunctionBlock) {
|
|
emitToken(SyntaxKind.CloseBraceToken, (<Block>node.body).statements.end);
|
|
}
|
|
else {
|
|
emitStart(node.body);
|
|
write("}");
|
|
emitEnd(node.body);
|
|
}
|
|
}
|
|
scopeEmitEnd();
|
|
if (node.flags & NodeFlags.Export) {
|
|
writeLine();
|
|
emitStart(node);
|
|
emitModuleMemberName(node);
|
|
write(" = ");
|
|
emit(node.name);
|
|
emitEnd(node);
|
|
write(";");
|
|
}
|
|
}
|
|
|
|
function findInitialSuperCall(ctor: ConstructorDeclaration): ExpressionStatement {
|
|
if (ctor.body) {
|
|
var statement = (<Block>ctor.body).statements[0];
|
|
if (statement && statement.kind === SyntaxKind.ExpressionStatement) {
|
|
var expr = (<ExpressionStatement>statement).expression;
|
|
if (expr && expr.kind === SyntaxKind.CallExpression) {
|
|
var func = (<CallExpression>expr).func;
|
|
if (func && func.kind === SyntaxKind.SuperKeyword) {
|
|
return <ExpressionStatement>statement;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function emitParameterPropertyAssignments(node: ConstructorDeclaration) {
|
|
forEach(node.parameters, param => {
|
|
if (param.flags & (NodeFlags.Public | NodeFlags.Private)) {
|
|
writeLine();
|
|
emitStart(param);
|
|
emitStart(param.name);
|
|
write("this.");
|
|
emitNode(param.name);
|
|
emitEnd(param.name);
|
|
write(" = ");
|
|
emit(param.name);
|
|
write(";");
|
|
emitEnd(param);
|
|
}
|
|
});
|
|
}
|
|
|
|
function emitMemberAccess(memberName: Identifier) {
|
|
if (memberName.kind === SyntaxKind.StringLiteral || memberName.kind === SyntaxKind.NumericLiteral) {
|
|
write("[");
|
|
emitNode(memberName);
|
|
write("]");
|
|
}
|
|
else {
|
|
write(".");
|
|
emitNode(memberName);
|
|
}
|
|
}
|
|
|
|
function emitMemberAssignments(node: ClassDeclaration, staticFlag: NodeFlags) {
|
|
forEach(node.members, member => {
|
|
if (member.kind === SyntaxKind.Property && (member.flags & NodeFlags.Static) === staticFlag && (<PropertyDeclaration>member).initializer) {
|
|
writeLine();
|
|
emitStart(member);
|
|
emitStart((<PropertyDeclaration>member).name);
|
|
if (staticFlag) {
|
|
emitNode(node.name);
|
|
}
|
|
else {
|
|
write("this");
|
|
}
|
|
emitMemberAccess((<PropertyDeclaration>member).name);
|
|
emitEnd((<PropertyDeclaration>member).name);
|
|
write(" = ");
|
|
emit((<PropertyDeclaration>member).initializer);
|
|
write(";");
|
|
emitEnd(member);
|
|
}
|
|
});
|
|
}
|
|
|
|
function emitMemberFunctions(node: ClassDeclaration) {
|
|
forEach(node.members, member => {
|
|
if (member.kind === SyntaxKind.Method) {
|
|
if (!(<MethodDeclaration>member).body) return;
|
|
writeLine();
|
|
emitStart(member);
|
|
emitStart((<MethodDeclaration>member).name);
|
|
emitNode(node.name);
|
|
if (!(member.flags & NodeFlags.Static)) {
|
|
write(".prototype");
|
|
}
|
|
emitMemberAccess((<MethodDeclaration>member).name);
|
|
emitEnd((<MethodDeclaration>member).name);
|
|
write(" = ");
|
|
emitStart(member);
|
|
emitFunctionDeclaration(<MethodDeclaration>member);
|
|
emitEnd(member);
|
|
emitEnd(member);
|
|
write(";");
|
|
}
|
|
else if (member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) {
|
|
var accessors = getAllAccessorDeclarations(node, <AccessorDeclaration>member);
|
|
if (member === accessors.firstAccessor) {
|
|
writeLine();
|
|
emitStart(member);
|
|
write("Object.defineProperty(");
|
|
emitStart((<AccessorDeclaration>member).name);
|
|
emitNode(node.name);
|
|
if (!(member.flags & NodeFlags.Static)) {
|
|
write(".prototype");
|
|
}
|
|
write(", ");
|
|
emitQuotedIdentifier((<AccessorDeclaration>member).name);
|
|
emitEnd((<AccessorDeclaration>member).name);
|
|
write(", {");
|
|
increaseIndent();
|
|
if (accessors.getAccessor) {
|
|
writeLine();
|
|
write("get: ");
|
|
emitStart(accessors.getAccessor);
|
|
write("function ");
|
|
emitSignatureAndBody(accessors.getAccessor);
|
|
emitEnd(accessors.getAccessor);
|
|
write(",");
|
|
}
|
|
if (accessors.setAccessor) {
|
|
writeLine();
|
|
write("set: ");
|
|
emitStart(accessors.setAccessor);
|
|
write("function ");
|
|
emitSignatureAndBody(accessors.setAccessor);
|
|
emitEnd(accessors.setAccessor);
|
|
write(",");
|
|
}
|
|
writeLine();
|
|
write("enumerable: true,");
|
|
writeLine();
|
|
write("configurable: true");
|
|
decreaseIndent();
|
|
writeLine();
|
|
write("});");
|
|
emitEnd(member);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
function emitClassDeclaration(node: ClassDeclaration) {
|
|
var ctor = findConstructor(node);
|
|
write("var ");
|
|
emit(node.name);
|
|
write(" = (function (");
|
|
if (node.baseType) write("_super");
|
|
write(") {");
|
|
increaseIndent();
|
|
scopeEmitStart(node);
|
|
if (node.baseType) {
|
|
writeLine();
|
|
emitStart(node.baseType);
|
|
write("__extends(");
|
|
emit(node.name);
|
|
write(", _super);");
|
|
emitEnd(node.baseType);
|
|
}
|
|
writeLine();
|
|
emitStart(<Node>ctor || node);
|
|
write("function ");
|
|
emit(node.name);
|
|
write("(");
|
|
if (ctor) {
|
|
emitCommaList(ctor.parameters);
|
|
}
|
|
write(") {");
|
|
scopeEmitStart(node, "constructor");
|
|
increaseIndent();
|
|
if (ctor) {
|
|
emitDefaultValueAssignments(ctor);
|
|
emitRestParameter(ctor);
|
|
if (node.baseType) {
|
|
var superCall = findInitialSuperCall(ctor);
|
|
if (superCall) {
|
|
writeLine();
|
|
emit(superCall);
|
|
}
|
|
}
|
|
emitParameterPropertyAssignments(ctor);
|
|
}
|
|
else {
|
|
if (node.baseType) {
|
|
writeLine();
|
|
emitStart(node.baseType);
|
|
write("_super.apply(this, arguments);");
|
|
emitEnd(node.baseType);
|
|
}
|
|
}
|
|
emitCaptureThisForNodeIfNecessary(node);
|
|
emitMemberAssignments(node, /*nonstatic*/0);
|
|
if (ctor) {
|
|
var statements: Node[] = (<Block>ctor.body).statements;
|
|
if (superCall) statements = statements.slice(1);
|
|
emitLines(statements);
|
|
}
|
|
decreaseIndent();
|
|
writeLine();
|
|
emitToken(SyntaxKind.CloseBraceToken, ctor ? (<Block>ctor.body).statements.end : node.members.end);
|
|
scopeEmitEnd();
|
|
emitEnd(<Node>ctor || node);
|
|
emitMemberFunctions(node);
|
|
emitMemberAssignments(node, NodeFlags.Static);
|
|
writeLine();
|
|
function emitClassReturnStatement() {
|
|
write("return ");
|
|
emitNode(node.name);
|
|
}
|
|
emitToken(SyntaxKind.CloseBraceToken, node.members.end, emitClassReturnStatement);
|
|
write(";");
|
|
decreaseIndent();
|
|
writeLine();
|
|
emitToken(SyntaxKind.CloseBraceToken, node.members.end);
|
|
scopeEmitEnd();
|
|
emitStart(node);
|
|
write(")(");
|
|
if (node.baseType) {
|
|
emit(node.baseType.typeName);
|
|
}
|
|
write(");");
|
|
emitEnd(node);
|
|
if (node.flags & NodeFlags.Export) {
|
|
writeLine();
|
|
emitStart(node);
|
|
emitModuleMemberName(node);
|
|
write(" = ");
|
|
emit(node.name);
|
|
emitEnd(node);
|
|
write(";");
|
|
}
|
|
}
|
|
|
|
function emitEnumDeclaration(node: EnumDeclaration) {
|
|
if (!(node.flags & NodeFlags.Export)) {
|
|
emitStart(node);
|
|
write("var ");
|
|
emit(node.name);
|
|
emitEnd(node);
|
|
write(";");
|
|
}
|
|
writeLine();
|
|
emitStart(node);
|
|
write("(function (");
|
|
emit(node.name);
|
|
write(") {");
|
|
increaseIndent();
|
|
scopeEmitStart(node);
|
|
forEach(node.members, member => {
|
|
writeLine();
|
|
emitStart(member);
|
|
emitNode(node.name);
|
|
write("[");
|
|
emitNode(node.name);
|
|
write("[");
|
|
emitQuotedIdentifier(member.name);
|
|
write("] = ");
|
|
if (member.initializer) {
|
|
emit(member.initializer);
|
|
}
|
|
else {
|
|
write(resolver.getEnumMemberValue(member).toString());
|
|
}
|
|
write("] = ");
|
|
emitQuotedIdentifier(member.name);
|
|
emitEnd(member);
|
|
write(";");
|
|
});
|
|
decreaseIndent();
|
|
writeLine();
|
|
emitToken(SyntaxKind.CloseBraceToken, node.members.end);
|
|
scopeEmitEnd();
|
|
write(")(");
|
|
emitModuleMemberName(node);
|
|
write(" || (");
|
|
emitModuleMemberName(node);
|
|
write(" = {}));");
|
|
emitEnd(node);
|
|
if (node.flags & NodeFlags.Export) {
|
|
writeLine();
|
|
emitStart(node);
|
|
write("var ");
|
|
emit(node.name);
|
|
write(" = ");
|
|
emitModuleMemberName(node);
|
|
emitEnd(node);
|
|
write(";");
|
|
}
|
|
}
|
|
|
|
function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration: ModuleDeclaration): ModuleDeclaration {
|
|
if (moduleDeclaration.body.kind === SyntaxKind.ModuleDeclaration) {
|
|
var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(<ModuleDeclaration>moduleDeclaration.body);
|
|
return recursiveInnerModule || <ModuleDeclaration>moduleDeclaration.body;
|
|
}
|
|
}
|
|
|
|
function emitModuleDeclaration(node: ModuleDeclaration) {
|
|
if (!isInstantiated(node)) return;
|
|
if (!(node.flags & NodeFlags.Export)) {
|
|
emitStart(node);
|
|
write("var ");
|
|
emit(node.name);
|
|
write(";");
|
|
emitEnd(node);
|
|
writeLine();
|
|
}
|
|
emitStart(node);
|
|
write("(function (");
|
|
emit(node.name);
|
|
write(") ");
|
|
if (node.body.kind === SyntaxKind.ModuleBlock) {
|
|
emit(node.body);
|
|
}
|
|
else {
|
|
write("{");
|
|
increaseIndent();
|
|
scopeEmitStart(node);
|
|
emitCaptureThisForNodeIfNecessary(node);
|
|
writeLine();
|
|
emit(node.body);
|
|
decreaseIndent();
|
|
writeLine();
|
|
var moduleBlock = <Block>getInnerMostModuleDeclarationFromDottedModule(node).body;
|
|
emitToken(SyntaxKind.CloseBraceToken, moduleBlock.statements.end);
|
|
scopeEmitEnd();
|
|
}
|
|
write(")(");
|
|
emitModuleMemberName(node);
|
|
write(" || (");
|
|
emitModuleMemberName(node);
|
|
write(" = {}));");
|
|
emitEnd(node);
|
|
if (node.flags & NodeFlags.Export) {
|
|
writeLine();
|
|
emitStart(node);
|
|
write("var ");
|
|
emit(node.name);
|
|
write(" = ");
|
|
emitModuleMemberName(node);
|
|
emitEnd(node);
|
|
write(";");
|
|
}
|
|
}
|
|
|
|
function emitImportDeclaration(node: ImportDeclaration) {
|
|
var emitImportDeclaration = resolver.isReferencedImportDeclaration(node);
|
|
|
|
if (!emitImportDeclaration) {
|
|
// preserve old compiler's behavior: emit 'var' for import declaration (even if we do not consider them referenced) when
|
|
// - current file is not external module
|
|
// - import declaration is top level and target is value imported by entity name
|
|
emitImportDeclaration = !(currentSourceFile.flags & NodeFlags.ExternalModule) && resolver.isTopLevelValueImportedViaEntityName(node);
|
|
}
|
|
|
|
if (emitImportDeclaration) {
|
|
if (node.externalModuleName && node.parent.kind === SyntaxKind.SourceFile && compilerOptions.module === ModuleKind.AMD) {
|
|
if (node.flags & NodeFlags.Export) {
|
|
writeLine();
|
|
emitStart(node);
|
|
emitModuleMemberName(node);
|
|
write(" = ");
|
|
emit(node.name);
|
|
write(";");
|
|
emitEnd(node);
|
|
}
|
|
}
|
|
else {
|
|
writeLine();
|
|
emitStart(node);
|
|
if (!(node.flags & NodeFlags.Export)) write("var ");
|
|
emitModuleMemberName(node);
|
|
write(" = ");
|
|
if (node.entityName) {
|
|
emit(node.entityName);
|
|
}
|
|
else {
|
|
write("require(");
|
|
emitStart(node.externalModuleName);
|
|
emitLiteral(node.externalModuleName);
|
|
emitEnd(node.externalModuleName);
|
|
emitToken(SyntaxKind.CloseParenToken, node.externalModuleName.end);
|
|
}
|
|
write(";");
|
|
emitEnd(node);
|
|
}
|
|
}
|
|
}
|
|
|
|
function getExternalImportDeclarations(node: SourceFile): ImportDeclaration[]{
|
|
var result: ImportDeclaration[] = [];
|
|
forEach(node.statements, stat => {
|
|
if (stat.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>stat).externalModuleName && resolver.isReferencedImportDeclaration(stat)) {
|
|
result.push(<ImportDeclaration>stat);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
|
|
function getFirstExportAssignment(sourceFile: SourceFile) {
|
|
return forEach(sourceFile.statements, node => {
|
|
if (node.kind === SyntaxKind.ExportAssignment) {
|
|
return <ExportAssignment>node;
|
|
}
|
|
});
|
|
}
|
|
|
|
function emitAMDModule(node: SourceFile) {
|
|
var imports = getExternalImportDeclarations(node);
|
|
writeLine();
|
|
write("define([\"require\", \"exports\"");
|
|
forEach(imports, imp => {
|
|
write(", ");
|
|
emitLiteral(imp.externalModuleName);
|
|
});
|
|
forEach(node.amdDependencies, amdDependency => {
|
|
var text = "\"" + amdDependency + "\"";
|
|
write(", ");
|
|
write(text);
|
|
});
|
|
write("], function (require, exports");
|
|
forEach(imports, imp => {
|
|
write(", ");
|
|
emit(imp.name);
|
|
});
|
|
write(") {");
|
|
increaseIndent();
|
|
emitCaptureThisForNodeIfNecessary(node);
|
|
emitLines(node.statements);
|
|
var exportName = resolver.getExportAssignmentName(node);
|
|
if (exportName) {
|
|
writeLine();
|
|
var exportAssignement = getFirstExportAssignment(node);
|
|
emitStart(exportAssignement);
|
|
write("return ");
|
|
emitStart(exportAssignement.exportName);
|
|
write(exportName);
|
|
emitEnd(exportAssignement.exportName);
|
|
write(";");
|
|
emitEnd(exportAssignement);
|
|
}
|
|
decreaseIndent();
|
|
writeLine();
|
|
write("});");
|
|
}
|
|
|
|
function emitCommonJSModule(node: SourceFile) {
|
|
emitCaptureThisForNodeIfNecessary(node);
|
|
emitLines(node.statements);
|
|
var exportName = resolver.getExportAssignmentName(node);
|
|
if (exportName) {
|
|
writeLine();
|
|
var exportAssignement = getFirstExportAssignment(node);
|
|
emitStart(exportAssignement);
|
|
write("module.exports = ");
|
|
emitStart(exportAssignement.exportName);
|
|
write(exportName);
|
|
emitEnd(exportAssignement.exportName);
|
|
write(";");
|
|
emitEnd(exportAssignement);
|
|
}
|
|
}
|
|
|
|
function emitSourceFile(node: SourceFile) {
|
|
currentSourceFile = node;
|
|
if (!extendsEmitted && resolver.getNodeCheckFlags(node) & NodeCheckFlags.EmitExtends) {
|
|
writeLine();
|
|
write("var __extends = this.__extends || function (d, b) {");
|
|
increaseIndent();
|
|
writeLine();
|
|
write("for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];");
|
|
writeLine();
|
|
write("function __() { this.constructor = d; }");
|
|
writeLine();
|
|
write("__.prototype = b.prototype;");
|
|
writeLine();
|
|
write("d.prototype = new __();");
|
|
decreaseIndent();
|
|
writeLine();
|
|
write("};");
|
|
extendsEmitted = true;
|
|
}
|
|
if (node.flags & NodeFlags.ExternalModule) {
|
|
if (compilerOptions.module === ModuleKind.AMD) {
|
|
emitAMDModule(node);
|
|
}
|
|
else {
|
|
emitCommonJSModule(node);
|
|
}
|
|
}
|
|
else {
|
|
emitCaptureThisForNodeIfNecessary(node);
|
|
emitLines(node.statements);
|
|
}
|
|
}
|
|
|
|
function emitNode(node: Node) {
|
|
if (!node || node.flags & NodeFlags.Ambient) return;
|
|
switch (node.kind) {
|
|
case SyntaxKind.Identifier:
|
|
return emitIdentifier(<Identifier>node);
|
|
case SyntaxKind.Parameter:
|
|
return emitParameter(<ParameterDeclaration>node);
|
|
case SyntaxKind.GetAccessor:
|
|
case SyntaxKind.SetAccessor:
|
|
return emitAccessor(<AccessorDeclaration>node);
|
|
case SyntaxKind.ThisKeyword:
|
|
return emitThis(node);
|
|
case SyntaxKind.SuperKeyword:
|
|
return emitSuper(node);
|
|
case SyntaxKind.NullKeyword:
|
|
return write("null");
|
|
case SyntaxKind.TrueKeyword:
|
|
return write("true");
|
|
case SyntaxKind.FalseKeyword:
|
|
return write("false");
|
|
case SyntaxKind.NumericLiteral:
|
|
case SyntaxKind.StringLiteral:
|
|
case SyntaxKind.RegularExpressionLiteral:
|
|
return emitLiteral(<LiteralExpression>node);
|
|
case SyntaxKind.QualifiedName:
|
|
return emitPropertyAccess(<QualifiedName>node);
|
|
case SyntaxKind.ArrayLiteral:
|
|
return emitArrayLiteral(<ArrayLiteral>node);
|
|
case SyntaxKind.ObjectLiteral:
|
|
return emitObjectLiteral(<ObjectLiteral>node);
|
|
case SyntaxKind.PropertyAssignment:
|
|
return emitPropertyAssignment(<PropertyDeclaration>node);
|
|
case SyntaxKind.PropertyAccess:
|
|
return emitPropertyAccess(<PropertyAccess>node);
|
|
case SyntaxKind.IndexedAccess:
|
|
return emitIndexedAccess(<IndexedAccess>node);
|
|
case SyntaxKind.CallExpression:
|
|
return emitCallExpression(<CallExpression>node);
|
|
case SyntaxKind.NewExpression:
|
|
return emitNewExpression(<NewExpression>node);
|
|
case SyntaxKind.TypeAssertion:
|
|
return emit((<TypeAssertion>node).operand);
|
|
case SyntaxKind.ParenExpression:
|
|
return emitParenExpression(<ParenExpression>node);
|
|
case SyntaxKind.FunctionDeclaration:
|
|
case SyntaxKind.FunctionExpression:
|
|
case SyntaxKind.ArrowFunction:
|
|
return emitFunctionDeclaration(<FunctionDeclaration>node);
|
|
case SyntaxKind.PrefixOperator:
|
|
case SyntaxKind.PostfixOperator:
|
|
return emitUnaryExpression(<UnaryExpression>node);
|
|
case SyntaxKind.BinaryExpression:
|
|
return emitBinaryExpression(<BinaryExpression>node);
|
|
case SyntaxKind.ConditionalExpression:
|
|
return emitConditionalExpression(<ConditionalExpression>node);
|
|
case SyntaxKind.Block:
|
|
case SyntaxKind.TryBlock:
|
|
case SyntaxKind.FinallyBlock:
|
|
case SyntaxKind.FunctionBlock:
|
|
case SyntaxKind.ModuleBlock:
|
|
return emitBlock(<Block>node);
|
|
case SyntaxKind.VariableStatement:
|
|
return emitVariableStatement(<VariableStatement>node);
|
|
case SyntaxKind.EmptyStatement:
|
|
return write(";");
|
|
case SyntaxKind.ExpressionStatement:
|
|
return emitExpressionStatement(<ExpressionStatement>node);
|
|
case SyntaxKind.IfStatement:
|
|
return emitIfStatement(<IfStatement>node);
|
|
case SyntaxKind.DoStatement:
|
|
return emitDoStatement(<DoStatement>node);
|
|
case SyntaxKind.WhileStatement:
|
|
return emitWhileStatement(<WhileStatement>node);
|
|
case SyntaxKind.ForStatement:
|
|
return emitForStatement(<ForStatement>node);
|
|
case SyntaxKind.ForInStatement:
|
|
return emitForInStatement(<ForInStatement>node);
|
|
case SyntaxKind.ContinueStatement:
|
|
case SyntaxKind.BreakStatement:
|
|
return emitBreakOrContinueStatement(<BreakOrContinueStatement>node);
|
|
case SyntaxKind.ReturnStatement:
|
|
return emitReturnStatement(<ReturnStatement>node);
|
|
case SyntaxKind.WithStatement:
|
|
return emitWithStatement(<WithStatement>node);
|
|
case SyntaxKind.SwitchStatement:
|
|
return emitSwitchStatement(<SwitchStatement>node);
|
|
case SyntaxKind.CaseClause:
|
|
case SyntaxKind.DefaultClause:
|
|
return emitCaseOrDefaultClause(<CaseOrDefaultClause>node);
|
|
case SyntaxKind.LabelledStatement:
|
|
return emitLabelledStatement(<LabelledStatement>node);
|
|
case SyntaxKind.ThrowStatement:
|
|
return emitThrowStatement(<ThrowStatement>node);
|
|
case SyntaxKind.TryStatement:
|
|
return emitTryStatement(<TryStatement>node);
|
|
case SyntaxKind.CatchBlock:
|
|
return emitCatchBlock(<CatchBlock>node);
|
|
case SyntaxKind.DebuggerStatement:
|
|
return emitDebuggerStatement(node);
|
|
case SyntaxKind.VariableDeclaration:
|
|
return emitVariableDeclaration(<VariableDeclaration>node);
|
|
case SyntaxKind.ClassDeclaration:
|
|
return emitClassDeclaration(<ClassDeclaration>node);
|
|
case SyntaxKind.EnumDeclaration:
|
|
return emitEnumDeclaration(<EnumDeclaration>node);
|
|
case SyntaxKind.ModuleDeclaration:
|
|
return emitModuleDeclaration(<ModuleDeclaration>node);
|
|
case SyntaxKind.ImportDeclaration:
|
|
return emitImportDeclaration(<ImportDeclaration>node);
|
|
case SyntaxKind.SourceFile:
|
|
return emitSourceFile(<SourceFile>node);
|
|
}
|
|
}
|
|
|
|
if (compilerOptions.sourceMap) {
|
|
initializeEmitterWithSourceMaps();
|
|
}
|
|
|
|
if (root) {
|
|
emit(root);
|
|
}
|
|
else {
|
|
forEach(program.getSourceFiles(), sourceFile => {
|
|
if (!isExternalModuleOrDeclarationFile(sourceFile)) {
|
|
emit(sourceFile);
|
|
}
|
|
});
|
|
}
|
|
|
|
writeLine();
|
|
writeEmittedFiles(writer.getText());
|
|
}
|
|
|
|
function emitDeclarations(resolver: EmitResolver, jsFilePath: string, root?: SourceFile) {
|
|
var program = resolver.getProgram();
|
|
var compilerOptions = program.getCompilerOptions();
|
|
var compilerHost = program.getCompilerHost();
|
|
|
|
var writer = createTextWriter();
|
|
var write = writer.write;
|
|
var writeLine = writer.writeLine;
|
|
var increaseIndent = writer.increaseIndent;
|
|
var decreaseIndent = writer.decreaseIndent;
|
|
|
|
function emitLines(nodes: Node[]) {
|
|
for (var i = 0, n = nodes.length; i < n; i++) {
|
|
emitNode(nodes[i]);
|
|
}
|
|
}
|
|
|
|
function emitCommaList(nodes: Node[]) {
|
|
for (var i = 0, n = nodes.length; i < n; i++) {
|
|
if (i) {
|
|
write(", ");
|
|
}
|
|
emitNode(nodes[i]);
|
|
}
|
|
}
|
|
|
|
function emitCommaTypeList(nodes: Node[]) {
|
|
if (nodes) {
|
|
for (var i = 0, n = nodes.length; i < n; i++) {
|
|
if (i) {
|
|
write(", ");
|
|
}
|
|
// TODO(shkamat): get the symbol name in the scope for this node
|
|
emitSourceTextOfNode(nodes[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function emitSourceTextOfNode(node: Node) {
|
|
write(getSourceTextOfLocalNode(node));
|
|
}
|
|
|
|
function emitSourceFile(node: SourceFile) {
|
|
currentSourceFile = node;
|
|
emitLines(node.statements);
|
|
}
|
|
|
|
function emitExportAssignment(node: ExportAssignment) {
|
|
write("export = ");
|
|
emitSourceTextOfNode(node.exportName);
|
|
write(";");
|
|
writeLine();
|
|
}
|
|
|
|
function emitImportDeclaration(node: ImportDeclaration) {
|
|
// TODO(shkamat): Emit if import decl is used to declare type in this context or as export assignment
|
|
if (node.flags & NodeFlags.Export) {
|
|
//TODO: only emit when export flag once the above condition is modified
|
|
write("export ");
|
|
write("import ");
|
|
write(getSourceTextOfLocalNode(node.name) + " = ");
|
|
if (node.entityName) {
|
|
emitSourceTextOfNode(node.entityName);
|
|
write(";");
|
|
}
|
|
else {
|
|
write("require(");
|
|
emitSourceTextOfNode(node.externalModuleName);
|
|
write(");");
|
|
}
|
|
writeLine();
|
|
}
|
|
}
|
|
|
|
function canEmitDeclaration(node: Declaration) {
|
|
if (node.parent.kind === SyntaxKind.ModuleDeclaration || node.parent.kind === SyntaxKind.SourceFile) {
|
|
if (!(node.flags & NodeFlags.Export)) {
|
|
// Non exported member
|
|
// TODO(shkamat): check if the symbol at this location is externally visible
|
|
// eg. because of export assignment or is in global context because source file is non external module
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function emitDeclarationFlags(node: Declaration) {
|
|
if (node.flags & NodeFlags.Static) {
|
|
if (node.flags & NodeFlags.Private) {
|
|
write("private ");
|
|
}
|
|
write("static ");
|
|
}
|
|
else {
|
|
if (node.flags & NodeFlags.Private) {
|
|
write("private ");
|
|
}
|
|
// If the node is parented in the current source file we need to emit export declare or just export
|
|
else if (node.parent === currentSourceFile) {
|
|
// If the node is exported
|
|
if (node.flags & NodeFlags.Export) {
|
|
write("export ");
|
|
}
|
|
|
|
if (node.kind !== SyntaxKind.InterfaceDeclaration) {
|
|
write("declare ");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function emitModuleDeclaration(node: ModuleDeclaration) {
|
|
if (canEmitDeclaration(node)) {
|
|
emitDeclarationFlags(node);
|
|
write("module ");
|
|
emitSourceTextOfNode(node.name);
|
|
while (node.body.kind !== SyntaxKind.ModuleBlock) {
|
|
node = <ModuleDeclaration>node.body;
|
|
write(".");
|
|
emitSourceTextOfNode(node.name);
|
|
}
|
|
write(" {");
|
|
writeLine();
|
|
increaseIndent();
|
|
emitLines((<Block>node.body).statements);
|
|
decreaseIndent();
|
|
write("}");
|
|
writeLine();
|
|
}
|
|
}
|
|
|
|
function emitEnumDeclaration(node: EnumDeclaration) {
|
|
if (canEmitDeclaration(node)) {
|
|
emitDeclarationFlags(node);
|
|
write("enum ");
|
|
emitSourceTextOfNode(node.name);
|
|
write(" {");
|
|
writeLine();
|
|
increaseIndent();
|
|
emitLines(node.members);
|
|
decreaseIndent();
|
|
write("}");
|
|
writeLine();
|
|
}
|
|
}
|
|
|
|
function emitEnumMemberDeclaration(node: EnumMember) {
|
|
emitSourceTextOfNode(node.name);
|
|
var enumMemberValue = resolver.getEnumMemberValue(node);
|
|
if (enumMemberValue !== undefined) {
|
|
write(" = ");
|
|
write(enumMemberValue.toString());
|
|
}
|
|
write(",");
|
|
writeLine();
|
|
}
|
|
|
|
function emitTypeParameters(typeParameters: TypeParameterDeclaration[]) {
|
|
if (typeParameters) {
|
|
write("<");
|
|
emitCommaTypeList(typeParameters);
|
|
write(">");
|
|
}
|
|
}
|
|
|
|
function emitHeritageClause(typeReferences: TypeReferenceNode[], isImplementsList: boolean) {
|
|
if (typeReferences) {
|
|
write(isImplementsList ? " implments " : " extends ");
|
|
emitCommaTypeList(typeReferences);
|
|
}
|
|
}
|
|
|
|
function emitClassDeclaration(node: ClassDeclaration) {
|
|
function emitParameterProperties(node: ConstructorDeclaration) {
|
|
if (node) {
|
|
forEach(node.parameters, param => {
|
|
if (param.flags & (NodeFlags.Public | NodeFlags.Private)) {
|
|
emitPropertyDeclaration(param);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
if (canEmitDeclaration(node)) {
|
|
emitDeclarationFlags(node);
|
|
write("class ");
|
|
emitSourceTextOfNode(node.name);
|
|
emitTypeParameters(node.typeParameters);
|
|
if (node.baseType) {
|
|
emitHeritageClause([node.baseType], /*isImplementsList*/ false);
|
|
}
|
|
emitHeritageClause(node.implementedTypes, /*isImplementsList*/ true);
|
|
write(" {");
|
|
writeLine();
|
|
increaseIndent();
|
|
emitParameterProperties(findConstructor(node));
|
|
emitLines(node.members);
|
|
decreaseIndent();
|
|
write("}");
|
|
writeLine();
|
|
}
|
|
}
|
|
|
|
function emitInterfaceDeclaration(node: InterfaceDeclaration) {
|
|
if (canEmitDeclaration(node)) {
|
|
emitDeclarationFlags(node);
|
|
write("interface ");
|
|
emitSourceTextOfNode(node.name);
|
|
emitTypeParameters(node.typeParameters);
|
|
emitHeritageClause(node.baseTypes, /*isImplementsList*/ false);
|
|
write(" {");
|
|
writeLine();
|
|
increaseIndent();
|
|
emitLines(node.members);
|
|
decreaseIndent();
|
|
write("}");
|
|
writeLine();
|
|
}
|
|
}
|
|
|
|
function emitPropertyDeclaration(node: PropertyDeclaration) {
|
|
emitDeclarationFlags(node);
|
|
emitVariableDeclaration(node);
|
|
write(";");
|
|
writeLine();
|
|
}
|
|
|
|
function emitVariableDeclaration(node: VariableDeclaration) {
|
|
emitSourceTextOfNode(node.name);
|
|
// If optional property emit ?
|
|
if (node.kind === SyntaxKind.Property && (node.flags & NodeFlags.QuestionMark)) {
|
|
write("?");
|
|
}
|
|
if (!(node.flags & NodeFlags.Private)) {
|
|
// TODO(shkamat): emit type of the node in given scope
|
|
}
|
|
}
|
|
|
|
function emitVariableStatement(node: VariableStatement) {
|
|
if (canEmitDeclaration(node)) {
|
|
emitDeclarationFlags(node);
|
|
write("var ");
|
|
emitCommaList(node.declarations);
|
|
write(";");
|
|
writeLine();
|
|
}
|
|
}
|
|
|
|
function emitAccessorDeclaration(node: AccessorDeclaration) {
|
|
var accessors = getAllAccessorDeclarations(<ClassDeclaration>node.parent, node);
|
|
if (node === accessors.firstAccessor) {
|
|
emitDeclarationFlags(node);
|
|
emitSourceTextOfNode(node.name);
|
|
if (!(node.flags & NodeFlags.Private)) {
|
|
// TODO(shkamat): emit type of the node in given scope
|
|
// If get accessor -> return type of getAccessor otherwise parameter type of setAccessor
|
|
}
|
|
write(";");
|
|
writeLine();
|
|
}
|
|
}
|
|
|
|
function emitFunctionDeclaration(node: FunctionDeclaration) {
|
|
// TODO(shkamat): if this is overloaded declaration do not emit if body is present
|
|
if (canEmitDeclaration(node)) {
|
|
emitDeclarationFlags(node);
|
|
if (node.kind === SyntaxKind.FunctionDeclaration) {
|
|
write("function ");
|
|
emitSourceTextOfNode(node.name);
|
|
}
|
|
else if (node.kind === SyntaxKind.Constructor) {
|
|
write("constructor ");
|
|
}
|
|
else {
|
|
emitSourceTextOfNode(node.name);
|
|
if (node.flags & NodeFlags.QuestionMark) {
|
|
write("?");
|
|
}
|
|
}
|
|
emitSignatureDeclaration(node);
|
|
}
|
|
}
|
|
|
|
function emitConstructSignatureDeclaration(node: SignatureDeclaration) {
|
|
write("new ");
|
|
emitSignatureDeclaration(node);
|
|
}
|
|
|
|
function emitSignatureDeclaration(node: SignatureDeclaration) {
|
|
emitTypeParameters(node.typeParameters);
|
|
if (node.kind === SyntaxKind.IndexSignature) {
|
|
write("[");
|
|
}
|
|
else {
|
|
write("(");
|
|
}
|
|
|
|
// Parameters
|
|
emitCommaList(node.parameters);
|
|
|
|
if (node.kind === SyntaxKind.IndexSignature) {
|
|
write("]");
|
|
}
|
|
else {
|
|
write(")");
|
|
}
|
|
|
|
if (!(node.flags & NodeFlags.Private)) {
|
|
// TODO(shkamat): emit return type of the signature
|
|
}
|
|
write(";");
|
|
writeLine();
|
|
}
|
|
|
|
function emitParameterDeclaration(node: ParameterDeclaration) {
|
|
if (node.flags & NodeFlags.Rest) {
|
|
write("...");
|
|
}
|
|
emitSourceTextOfNode(node.name);
|
|
if (node.initializer || (node.flags & NodeFlags.QuestionMark)) {
|
|
write("?");
|
|
}
|
|
|
|
if (!(node.parent.flags & NodeFlags.Private)) {
|
|
// TODO(shkamat): emitType of the parameter if the method is not private
|
|
}
|
|
}
|
|
|
|
function emitNode(node: Node) {
|
|
switch (node.kind) {
|
|
case SyntaxKind.Parameter:
|
|
return emitParameterDeclaration(<ParameterDeclaration>node);
|
|
case SyntaxKind.Constructor:
|
|
case SyntaxKind.FunctionDeclaration:
|
|
case SyntaxKind.Method:
|
|
return emitFunctionDeclaration(<FunctionDeclaration>node);
|
|
case SyntaxKind.ConstructSignature:
|
|
return emitConstructSignatureDeclaration(<SignatureDeclaration>node);
|
|
case SyntaxKind.CallSignature:
|
|
case SyntaxKind.IndexSignature:
|
|
return emitSignatureDeclaration(<SignatureDeclaration>node);
|
|
case SyntaxKind.GetAccessor:
|
|
case SyntaxKind.SetAccessor:
|
|
return emitAccessorDeclaration(<AccessorDeclaration>node);
|
|
case SyntaxKind.VariableStatement:
|
|
return emitVariableStatement(<VariableStatement>node);
|
|
case SyntaxKind.VariableDeclaration:
|
|
return emitVariableDeclaration(<VariableDeclaration>node);
|
|
case SyntaxKind.Property:
|
|
return emitPropertyDeclaration(<PropertyDeclaration>node);
|
|
case SyntaxKind.InterfaceDeclaration:
|
|
return emitInterfaceDeclaration(<InterfaceDeclaration>node);
|
|
case SyntaxKind.ClassDeclaration:
|
|
return emitClassDeclaration(<ClassDeclaration>node);
|
|
case SyntaxKind.EnumMember:
|
|
return emitEnumMemberDeclaration(<EnumMember>node);
|
|
case SyntaxKind.EnumDeclaration:
|
|
return emitEnumDeclaration(<EnumDeclaration>node);
|
|
case SyntaxKind.ModuleDeclaration:
|
|
return emitModuleDeclaration(<ModuleDeclaration>node);
|
|
case SyntaxKind.ImportDeclaration:
|
|
return emitImportDeclaration(<ImportDeclaration>node);
|
|
case SyntaxKind.ExportAssignment:
|
|
return emitExportAssignment(<ExportAssignment>node);
|
|
case SyntaxKind.SourceFile:
|
|
return emitSourceFile(<SourceFile>node);
|
|
}
|
|
}
|
|
|
|
function resolveScriptReference(sourceFile: SourceFile, reference: FileReference) {
|
|
var referenceFileName = compilerOptions.noResolve
|
|
? reference.filename
|
|
: normalizePath(combinePaths(getDirectoryPath(sourceFile.filename), reference.filename));
|
|
return program.getSourceFile(referenceFileName);
|
|
}
|
|
|
|
// Contains the reference paths that needs to go in the declaration file.
|
|
// Collecting this separately because reference paths need to be first thing in the declaration file
|
|
// and we could be collecting these paths from multiple files into single one with --out option
|
|
var referencePathsOutput = "";
|
|
function writeReferencePath(referencedFile: SourceFile) {
|
|
var declFileName = referencedFile.flags & NodeFlags.DeclarationFile
|
|
? referencedFile.filename // Declaration file, use declaration file name
|
|
: emitToOwnOutputFile(referencedFile, compilerOptions)
|
|
? getOwnEmitOutputFilePath(referencedFile, program, ".d.ts") // Own output file so get the .d.ts file
|
|
: getModuleNameFromFilename(compilerOptions.out) + ".d.ts";// Global out file
|
|
|
|
declFileName = getRelativePathToDirectoryOrUrl(
|
|
getDirectoryPath(normalizeSlashes(jsFilePath)),
|
|
declFileName,
|
|
compilerHost.getCurrentDirectory(),
|
|
/*isAbsolutePathAnUrl*/ false);
|
|
|
|
referencePathsOutput += "/// <reference path='" + declFileName + "' />" + sys.newLine;
|
|
}
|
|
|
|
if (root) {
|
|
// Emiting single file so emit references in this file only
|
|
var addedGlobalFileReference = false;
|
|
forEach(root.referencedFiles, fileReference => {
|
|
var referencedFile = resolveScriptReference(root, fileReference);
|
|
|
|
// All the references that are not going to be part of same file
|
|
if ((referencedFile.flags & NodeFlags.DeclarationFile) || // This is a declare file reference
|
|
emitToOwnOutputFile(referencedFile, compilerOptions) || // This is referenced file is emitting its own js file
|
|
!addedGlobalFileReference) { // Or the global out file corresponding to this reference was not added
|
|
|
|
writeReferencePath(referencedFile);
|
|
if (!isExternalModuleOrDeclarationFile(referencedFile)) {
|
|
addedGlobalFileReference = true;
|
|
}
|
|
}
|
|
});
|
|
|
|
emitNode(root);
|
|
}
|
|
else {
|
|
// Emit references corresponding to this file
|
|
var emittedReferencedFiles: SourceFile[] = [];
|
|
forEach(program.getSourceFiles(), sourceFile => {
|
|
if (!isExternalModuleOrDeclarationFile(sourceFile)) {
|
|
// Check what references need to be added
|
|
forEach(sourceFile.referencedFiles, fileReference => {
|
|
var referencedFile = resolveScriptReference(sourceFile, fileReference);
|
|
|
|
// If the reference file is declaration file or external module emit that reference
|
|
if (isExternalModuleOrDeclarationFile(referencedFile) &&
|
|
!contains(emittedReferencedFiles, referencedFile)) { // If the file refernece was not already emitted
|
|
|
|
writeReferencePath(referencedFile);
|
|
emittedReferencedFiles.push(referencedFile);
|
|
}
|
|
});
|
|
|
|
emitNode(sourceFile);
|
|
}
|
|
});
|
|
}
|
|
|
|
compilerHost.writeFile(getModuleNameFromFilename(jsFilePath) + ".d.ts", referencePathsOutput + writer.getText());
|
|
}
|
|
}
|