/// <reference path="checker.ts"/>

module ts {

interface EmitTextWriter {

write(s: string): void;

writeTextOfNode(sourceFile: SourceFile, node: Node): void;

writeLine(): void;

increaseIndent(): void;

decreaseIndent(): void;

getText(): string;

rawWrite(s: string): void;

writeLiteral(s: string): void;

getTextPos(): number;

getLine(): number;

getColumn(): number;

getIndent(): number;

}

interface SymbolAccessibilityDiagnostic {

errorNode: Node;

diagnosticMessage: DiagnosticMessage;

typeName?: DeclarationName;

}

type GetSymbolAccessibilityDiagnostic = (symbolAccesibilityResult: SymbolAccessiblityResult) => SymbolAccessibilityDiagnostic;

interface EmitTextWriterWithSymbolWriter extends EmitTextWriter, SymbolWriter {

getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic;

}

interface AliasDeclarationEmitInfo {

declaration: ImportDeclaration;

outputPos: number;

indent: number;

asynchronousOutput?: string; // If the output for alias was written asynchronously, the corresponding output

}

interface DeclarationEmit {

reportedDeclarationError: boolean;

aliasDeclarationEmitInfo: AliasDeclarationEmitInfo[];

synchronousDeclarationOutput: string;

referencePathsOutput: string;

}

var indentStrings: string[] = ["", " "];

export function getIndentString(level: number) {

if (indentStrings[level] === undefined) {

indentStrings[level] = getIndentString(level - 1) + indentStrings[1];

}

return indentStrings[level];

}

function getIndentSize() {

return indentStrings[1].length;

}

export function shouldEmitToOwnFile(sourceFile: SourceFile, compilerOptions: CompilerOptions): boolean {

if (!isDeclarationFile(sourceFile)) {

if ((isExternalModule(sourceFile) || !compilerOptions.out) && !fileExtensionIs(sourceFile.fileName, ".js")) {

return true;

}

return false;

}

return false;

}

export function isExternalModuleOrDeclarationFile(sourceFile: SourceFile) {

return isExternalModule(sourceFile) || isDeclarationFile(sourceFile);

}

function createTextWriter(newLine: String): EmitTextWriter {

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 rawWrite(s: string) {

if (s !== undefined) {

if (lineStart) {

lineStart = false;

}

output += s;

}

}

function writeLiteral(s: string) {

if (s && s.length) {

write(s);

var lineStartsOfS = computeLineStarts(s);

if (lineStartsOfS.length > 1) {

lineCount = lineCount + lineStartsOfS.length - 1;

linePos = output.length - s.length + lineStartsOfS[lineStartsOfS.length - 1];

}

}

}

function writeLine() {

if (!lineStart) {

output += newLine;

lineCount++;

linePos = output.length;

lineStart = true;

}

}

function writeTextOfNode(sourceFile: SourceFile, node: Node) {

write(getSourceTextOfNodeFromSourceFile(sourceFile, node));

}

return {

write,

rawWrite,

writeTextOfNode,

writeLiteral,

writeLine,

increaseIndent: () => indent++,

decreaseIndent: () => indent--,

getIndent: () => indent,

getTextPos: () => output.length,

getLine: () => lineCount + 1,

getColumn: () => lineStart ? indent * getIndentSize() + 1 : output.length - linePos + 1,

getText: () => output,

};

}

function getLineOfLocalPosition(currentSourceFile: SourceFile, pos: number) {

return getLineAndCharacterOfPosition(currentSourceFile, pos).line;

}

function emitNewLineBeforeLeadingComments(currentSourceFile: SourceFile, writer: EmitTextWriter, node: TextRange, leadingComments: CommentRange[]) {

// If the leading comments start on different line than the start of node, write new line

if (leadingComments && leadingComments.length && node.pos !== leadingComments[0].pos &&

getLineOfLocalPosition(currentSourceFile, node.pos) !== getLineOfLocalPosition(currentSourceFile, leadingComments[0].pos)) {

writer.writeLine();

}

}

function emitComments(currentSourceFile: SourceFile, writer: EmitTextWriter, comments: CommentRange[], trailingSeparator: boolean, newLine: string,

writeComment: (currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string) => void) {

var emitLeadingSpace = !trailingSeparator;

forEach(comments, comment => {

if (emitLeadingSpace) {

writer.write(" ");

emitLeadingSpace = false;

}

writeComment(currentSourceFile, writer, comment, newLine);

if (comment.hasTrailingNewLine) {

writer.writeLine();

}

else if (trailingSeparator) {

writer.write(" ");

}

else {

// Emit leading space to separate comment during next comment emit

emitLeadingSpace = true;

}

});

}

function writeCommentRange(currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string){

if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk) {

var firstCommentLineAndCharacter = getLineAndCharacterOfPosition(currentSourceFile, comment.pos);

var lastLine = getLineStarts(currentSourceFile).length;

var firstCommentLineIndent: number;

for (var pos = comment.pos, currentLine = firstCommentLineAndCharacter.line; pos < comment.end; currentLine++) {

var nextLineStart = currentLine === lastLine ? (comment.end + 1) : getPositionFromLineAndCharacter(currentSourceFile, currentLine + 1, /*character*/1);

if (pos !== comment.pos) {

// If we are not emitting first line, we need to write the spaces to adjust the alignment

if (firstCommentLineIndent === undefined) {

firstCommentLineIndent = calculateIndent(getPositionFromLineAndCharacter(currentSourceFile, firstCommentLineAndCharacter.line, /*character*/1),

comment.pos);

}

// These are number of spaces writer is going to write at current indent

var currentWriterIndentSpacing = writer.getIndent() * getIndentSize();

// Number of spaces we want to be writing

// eg: Assume writer indent

// module m {

// /* starts at character 9 this is line 1

// * starts at character pos 4 line --1 = 8 - 8 + 3

// More left indented comment */ --2 = 8 - 8 + 2

// class c { }

// }

// module m {

// /* this is line 1 -- Assume current writer indent 8

// * line --3 = 8 - 4 + 5

// More right indented comment */ --4 = 8 - 4 + 11

// class c { }

// }

var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(pos, nextLineStart);

if (spacesToEmit > 0) {

var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize();

var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());

// Write indent size string ( in eg 1: = "", 2: "" , 3: string with 8 spaces 4: string with 12 spaces

writer.rawWrite(indentSizeSpaceString);

// Emit the single spaces (in eg: 1: 3 spaces, 2: 2 spaces, 3: 1 space, 4: 3 spaces)

while (numberOfSingleSpacesToEmit) {

writer.rawWrite(" ");

numberOfSingleSpacesToEmit--;

}

}

else {

// No spaces to emit write empty string

writer.rawWrite("");

}

}

// Write the comment line text

writeTrimmedCurrentLine(pos, nextLineStart);

pos = nextLineStart;

}

}

else {

// Single line comment of style //....

writer.write(currentSourceFile.text.substring(comment.pos, comment.end));

}

function writeTrimmedCurrentLine(pos: number, nextLineStart: number) {

var end = Math.min(comment.end, nextLineStart - 1);

var currentLineText = currentSourceFile.text.substring(pos, end).replace(/^\s+|\s+$/g, '');

if (currentLineText) {

// trimmed forward and ending spaces text

writer.write(currentLineText);

if (end !== comment.end) {

writer.writeLine();

}

}

else {

// Empty string - make sure we write empty line

writer.writeLiteral(newLine);

}

}

function calculateIndent(pos: number, end: number) {

var currentLineIndent = 0;

for (; pos < end && isWhiteSpace(currentSourceFile.text.charCodeAt(pos)); pos++) {

if (currentSourceFile.text.charCodeAt(pos) === CharacterCodes.tab) {

// Tabs = TabSize = indent size and go to next tabStop

currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize());

}

else {

// Single space

currentLineIndent++;

}

}

return currentLineIndent;

}

}

function getFirstConstructorWithBody(node: ClassDeclaration): ConstructorDeclaration {

return forEach(node.members, member => {

if (member.kind === SyntaxKind.Constructor && nodeIsPresent((<ConstructorDeclaration>member).body)) {

return <ConstructorDeclaration>member;

}

});

}

function getAllAccessorDeclarations(node: ClassDeclaration, accessor: AccessorDeclaration) {

var firstAccessor: AccessorDeclaration;

var getAccessor: AccessorDeclaration;

var setAccessor: AccessorDeclaration;

if (accessor.name.kind === SyntaxKind.ComputedPropertyName) {

firstAccessor = accessor;

if (accessor.kind === SyntaxKind.GetAccessor) {

getAccessor = accessor;

}

else if (accessor.kind === SyntaxKind.SetAccessor) {

setAccessor = accessor;

}

else {

Debug.fail("Accessor has wrong kind");

}

}

else {

forEach(node.members,(member: Declaration) => {

if ((member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) &&

(<Identifier>member.name).text === (<Identifier>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,

getAccessor,

setAccessor

};

}

function getSourceFilePathInNewDir(sourceFile: SourceFile, host: EmitHost, newDirPath: string) {

var sourceFilePath = getNormalizedAbsolutePath(sourceFile.fileName, host.getCurrentDirectory());

sourceFilePath = sourceFilePath.replace(host.getCommonSourceDirectory(), "");

return combinePaths(newDirPath, sourceFilePath);

}

function getOwnEmitOutputFilePath(sourceFile: SourceFile, host: EmitHost, extension: string){

var compilerOptions = host.getCompilerOptions();

if (compilerOptions.outDir) {

var emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(sourceFile, host, compilerOptions.outDir));

}

else {

var emitOutputFilePathWithoutExtension = removeFileExtension(sourceFile.fileName);

}

return emitOutputFilePathWithoutExtension + extension;

}

function writeFile(host: EmitHost, diagnostics: Diagnostic[], fileName: string, data: string, writeByteOrderMark: boolean) {

host.writeFile(fileName, data, writeByteOrderMark, hostErrorMessage => {

diagnostics.push(createCompilerDiagnostic(Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage));

});

}

function emitDeclarations(host: EmitHost, resolver: EmitResolver, diagnostics: Diagnostic[], jsFilePath: string, root?: SourceFile): DeclarationEmit {

var newLine = host.getNewLine();

var compilerOptions = host.getCompilerOptions();

var languageVersion = compilerOptions.target || ScriptTarget.ES3;

var write: (s: string) => void;

var writeLine: () => void;

var increaseIndent: () => void;

var decreaseIndent: () => void;

var writeTextOfNode: (sourceFile: SourceFile, node: Node) => void;

var writer = createAndSetNewTextWriterWithSymbolWriter();

var enclosingDeclaration: Node;

var currentSourceFile: SourceFile;

var reportedDeclarationError = false;

var emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;

var emit = compilerOptions.stripInternal ? stripInternal : emitNode;

var aliasDeclarationEmitInfo: AliasDeclarationEmitInfo[] = [];

// 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 = "";

if (root) {

// Emitting just a single file, so emit references in this file only

if (!compilerOptions.noResolve) {

var addedGlobalFileReference = false;

forEach(root.referencedFiles, fileReference => {

var referencedFile = tryResolveScriptReference(host, root, fileReference);

// All the references that are not going to be part of same file

if (referencedFile && ((referencedFile.flags & NodeFlags.DeclarationFile) || // This is a declare file reference

shouldEmitToOwnFile(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;

}

}

});

}

emitSourceFile(root);

}

else {

// Emit references corresponding to this file

var emittedReferencedFiles: SourceFile[] = [];

forEach(host.getSourceFiles(), sourceFile => {

if (!isExternalModuleOrDeclarationFile(sourceFile)) {

// Check what references need to be added

if (!compilerOptions.noResolve) {

forEach(sourceFile.referencedFiles, fileReference => {

var referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);

// If the reference file is a declaration file or an external module, emit that reference

if (referencedFile && (isExternalModuleOrDeclarationFile(referencedFile) &&

!contains(emittedReferencedFiles, referencedFile))) { // If the file reference was not already emitted

writeReferencePath(referencedFile);

emittedReferencedFiles.push(referencedFile);

}

});

}

emitSourceFile(sourceFile);

}

});

}

return {

reportedDeclarationError,

aliasDeclarationEmitInfo,

synchronousDeclarationOutput: writer.getText(),

referencePathsOutput,

}

function hasInternalAnnotation(range: CommentRange) {

var text = currentSourceFile.text;

var comment = text.substring(range.pos, range.end);

return comment.indexOf("@internal") >= 0;

}

function stripInternal(node: Node) {

if (node) {

var leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);

if (forEach(leadingCommentRanges, hasInternalAnnotation)) {

return;

}

emitNode(node);

}

}

function createAndSetNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {

var writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);

writer.trackSymbol = trackSymbol;

writer.writeKeyword = writer.write;

writer.writeOperator = writer.write;

writer.writePunctuation = writer.write;

writer.writeSpace = writer.write;

writer.writeStringLiteral = writer.writeLiteral;

writer.writeParameter = writer.write;

writer.writeSymbol = writer.write;

setWriter(writer);

return writer;

}

function setWriter(newWriter: EmitTextWriterWithSymbolWriter) {

writer = newWriter;

write = newWriter.write;

writeTextOfNode = newWriter.writeTextOfNode;

writeLine = newWriter.writeLine;

increaseIndent = newWriter.increaseIndent;

decreaseIndent = newWriter.decreaseIndent;

}

function writeAsychronousImportDeclarations(importDeclarations: ImportDeclaration[]) {

var oldWriter = writer;

forEach(importDeclarations, aliasToWrite => {

var aliasEmitInfo = forEach(aliasDeclarationEmitInfo, declEmitInfo => declEmitInfo.declaration === aliasToWrite ? declEmitInfo : undefined);

// If the alias was marked as not visible when we saw its declaration, we would have saved the aliasEmitInfo, but if we haven't yet visited the alias declaration

// then we don't need to write it at this point. We will write it when we actually see its declaration

// Eg.

// export function bar(a: foo.Foo) { }

// import foo = require("foo");

// Writing of function bar would mark alias declaration foo as visible but we haven't yet visited that declaration so do nothing,

// we would write alias foo declaration when we visit it since it would now be marked as visible

if (aliasEmitInfo) {

createAndSetNewTextWriterWithSymbolWriter();

for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) {

increaseIndent();

}

writeImportDeclaration(aliasToWrite);

aliasEmitInfo.asynchronousOutput = writer.getText();

}

});

setWriter(oldWriter);

}

function handleSymbolAccessibilityError(symbolAccesibilityResult: SymbolAccessiblityResult) {

if (symbolAccesibilityResult.accessibility === SymbolAccessibility.Accessible) {

// write the aliases

if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) {

writeAsychronousImportDeclarations(symbolAccesibilityResult.aliasesToMakeVisible);

}

}

else {

// Report error

reportedDeclarationError = true;

var errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult);

if (errorInfo) {

if (errorInfo.typeName) {

diagnostics.push(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,

errorInfo.diagnosticMessage,

getSourceTextOfNodeFromSourceFile(currentSourceFile, errorInfo.typeName),

symbolAccesibilityResult.errorSymbolName,

symbolAccesibilityResult.errorModuleName));

}

else {

diagnostics.push(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,

errorInfo.diagnosticMessage,

symbolAccesibilityResult.errorSymbolName,

symbolAccesibilityResult.errorModuleName));

}

}

}

}

function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {

handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));

}

function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode | StringLiteralExpression, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {

writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;

write(": ");

if (type) {

// Write the type

emitType(type);

}

else {

resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);

}

}

function writeReturnTypeAtSignature(signature: SignatureDeclaration, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {

writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;

write(": ");

if (signature.type) {

// Write the type

emitType(signature.type);

}

else {

resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);

}

}

function emitLines(nodes: Node[]) {

for (var i = 0, n = nodes.length; i < n; i++) {

emit(nodes[i]);

}

}

function emitSeparatedList(nodes: Node[], separator: string, eachNodeEmitFn: (node: Node) => void) {

var currentWriterPos = writer.getTextPos();

for (var i = 0, n = nodes.length; i < n; i++) {

if (currentWriterPos !== writer.getTextPos()) {

write(separator);

}

currentWriterPos = writer.getTextPos();

eachNodeEmitFn(nodes[i]);

}

}

function emitCommaList(nodes: Node[], eachNodeEmitFn: (node: Node) => void) {

emitSeparatedList(nodes, ", ", eachNodeEmitFn);

}

function writeJsDocComments(declaration: Node) {

if (declaration) {

var jsDocComments = getJsDocComments(declaration, currentSourceFile);

emitNewLineBeforeLeadingComments(currentSourceFile, writer, declaration, jsDocComments);

// jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space

emitComments(currentSourceFile, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);

}

}

function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type: TypeNode | EntityName, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {

writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;

emitType(type);

}

function emitType(type: TypeNode | StringLiteralExpression | Identifier | QualifiedName) {

switch (type.kind) {

case SyntaxKind.AnyKeyword:

case SyntaxKind.StringKeyword:

case SyntaxKind.NumberKeyword:

case SyntaxKind.BooleanKeyword:

case SyntaxKind.VoidKeyword:

case SyntaxKind.StringLiteral:

return writeTextOfNode(currentSourceFile, type);

case SyntaxKind.TypeReference:

return emitTypeReference(<TypeReferenceNode>type);

case SyntaxKind.TypeQuery:

return emitTypeQuery(<TypeQueryNode>type);

case SyntaxKind.ArrayType:

return emitArrayType(<ArrayTypeNode>type);

case SyntaxKind.TupleType:

return emitTupleType(<TupleTypeNode>type);

case SyntaxKind.UnionType:

return emitUnionType(<UnionTypeNode>type);

case SyntaxKind.ParenthesizedType:

return emitParenType(<ParenthesizedTypeNode>type);

case SyntaxKind.FunctionType:

case SyntaxKind.ConstructorType:

return emitSignatureDeclarationWithJsDocComments(<FunctionOrConstructorTypeNode>type);

case SyntaxKind.TypeLiteral:

return emitTypeLiteral(<TypeLiteralNode>type);

case SyntaxKind.Identifier:

return emitEntityName(<Identifier>type);

case SyntaxKind.QualifiedName:

return emitEntityName(<QualifiedName>type);

default:

Debug.fail("Unknown type annotation: " + type.kind);

}

function emitEntityName(entityName: EntityName) {

var visibilityResult = resolver.isEntityNameVisible(entityName,

// Aliases can be written asynchronously so use correct enclosing declaration

entityName.parent.kind === SyntaxKind.ImportDeclaration ? entityName.parent : enclosingDeclaration);

handleSymbolAccessibilityError(visibilityResult);

writeEntityName(entityName);

function writeEntityName(entityName: EntityName) {

if (entityName.kind === SyntaxKind.Identifier) {

writeTextOfNode(currentSourceFile, entityName);

}

else {

var qualifiedName = <QualifiedName>entityName;

writeEntityName(qualifiedName.left);

write(".");

writeTextOfNode(currentSourceFile, qualifiedName.right);

}

}

}

function emitTypeReference(type: TypeReferenceNode) {

emitEntityName(type.typeName);

if (type.typeArguments) {

write("<");

emitCommaList(type.typeArguments, emitType);

write(">");

}

}

function emitTypeQuery(type: TypeQueryNode) {

write("typeof ");

emitEntityName(type.exprName);

}

function emitArrayType(type: ArrayTypeNode) {

emitType(type.elementType);

write("[]");

}

function emitTupleType(type: TupleTypeNode) {

write("[");

emitCommaList(type.elementTypes, emitType);

write("]");

}

function emitUnionType(type: UnionTypeNode) {

emitSeparatedList(type.types, " | ", emitType);

}

function emitParenType(type: ParenthesizedTypeNode) {

write("(");

emitType(type.type);

write(")");

}

function emitTypeLiteral(type: TypeLiteralNode) {

write("{");

if (type.members.length) {

writeLine();

increaseIndent();

// write members

emitLines(type.members);

decreaseIndent();

}

write("}");

}

}

function emitSourceFile(node: SourceFile) {

currentSourceFile = node;

enclosingDeclaration = node;

emitLines(node.statements);

}

function emitExportAssignment(node: ExportAssignment) {

write("export = ");

writeTextOfNode(currentSourceFile, node.exportName);

write(";");

writeLine();

}

function emitModuleElementDeclarationFlags(node: Node) {

// If the node is parented in the current source file we need to emit export declare or just export

if (node.parent === currentSourceFile) {

// If the node is exported

if (node.flags & NodeFlags.Export) {

write("export ");

}

if (node.kind !== SyntaxKind.InterfaceDeclaration) {

write("declare ");

}

}

}

function emitClassMemberDeclarationFlags(node: Declaration) {

if (node.flags & NodeFlags.Private) {

write("private ");

}

else if (node.flags & NodeFlags.Protected) {

write("protected ");

}

if (node.flags & NodeFlags.Static) {

write("static ");

}

}

function emitImportDeclaration(node: ImportDeclaration) {

var nodeEmitInfo = {

declaration: node,

outputPos: writer.getTextPos(),

indent: writer.getIndent(),

hasWritten: resolver.isDeclarationVisible(node)

};

aliasDeclarationEmitInfo.push(nodeEmitInfo);

if (nodeEmitInfo.hasWritten) {

writeImportDeclaration(node);

}

}

function writeImportDeclaration(node: ImportDeclaration) {

// note usage of writer. methods instead of aliases created, just to make sure we are using

// correct writer especially to handle asynchronous alias writing

emitJsDocComments(node);

if (node.flags & NodeFlags.Export) {

write("export ");

}

write("import ");

writeTextOfNode(currentSourceFile, node.name);

write(" = ");

if (isInternalModuleImportDeclaration(node)) {

emitTypeWithNewGetSymbolAccessibilityDiagnostic(<EntityName>node.moduleReference, getImportEntityNameVisibilityError);

write(";");

}

else {

write("require(");

writeTextOfNode(currentSourceFile, getExternalModuleImportDeclarationExpression(node));

write(");");

}

writer.writeLine();

function getImportEntityNameVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {

return {

diagnosticMessage: Diagnostics.Import_declaration_0_is_using_private_name_1,

errorNode: node,

typeName: node.name

};

}

}

function emitModuleDeclaration(node: ModuleDeclaration) {

if (resolver.isDeclarationVisible(node)) {

emitJsDocComments(node);

emitModuleElementDeclarationFlags(node);

write("module ");

writeTextOfNode(currentSourceFile, node.name);

while (node.body.kind !== SyntaxKind.ModuleBlock) {

node = <ModuleDeclaration>node.body;

write(".");

writeTextOfNode(currentSourceFile, node.name);

}

var prevEnclosingDeclaration = enclosingDeclaration;

enclosingDeclaration = node;

write(" {");

writeLine();

increaseIndent();

emitLines((<ModuleBlock>node.body).statements);

decreaseIndent();

write("}");

writeLine();

enclosingDeclaration = prevEnclosingDeclaration;

}

}

function emitTypeAliasDeclaration(node: TypeAliasDeclaration) {

if (resolver.isDeclarationVisible(node)) {

emitJsDocComments(node);

emitModuleElementDeclarationFlags(node);

write("type ");

writeTextOfNode(currentSourceFile, node.name);

write(" = ");

emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.type, getTypeAliasDeclarationVisibilityError);

write(";");

writeLine();

}

function getTypeAliasDeclarationVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {

return {

diagnosticMessage: Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,

errorNode: node.type,

typeName: node.name

};

}

}

function emitEnumDeclaration(node: EnumDeclaration) {

if (resolver.isDeclarationVisible(node)) {

emitJsDocComments(node);

emitModuleElementDeclarationFlags(node);

if (isConst(node)) {

write("const ")

}

write("enum ");

writeTextOfNode(currentSourceFile, node.name);

write(" {");

writeLine();

increaseIndent();

emitLines(node.members);

decreaseIndent();

write("}");

writeLine();

}

}

function emitEnumMemberDeclaration(node: EnumMember) {

emitJsDocComments(node);

writeTextOfNode(currentSourceFile, node.name);

var enumMemberValue = resolver.getConstantValue(node);

if (enumMemberValue !== undefined) {

write(" = ");

write(enumMemberValue.toString());

}

write(",");

writeLine();

}

function isPrivateMethodTypeParameter(node: TypeParameterDeclaration) {

return node.parent.kind === SyntaxKind.MethodDeclaration && (node.parent.flags & NodeFlags.Private);

}

function emitTypeParameters(typeParameters: TypeParameterDeclaration[]) {

function emitTypeParameter(node: TypeParameterDeclaration) {

increaseIndent();

emitJsDocComments(node);

decreaseIndent();

writeTextOfNode(currentSourceFile, node.name);

// If there is constraint present and this is not a type parameter of the private method emit the constraint

if (node.constraint && !isPrivateMethodTypeParameter(node)) {

write(" extends ");

if (node.parent.kind === SyntaxKind.FunctionType ||

node.parent.kind === SyntaxKind.ConstructorType ||

(node.parent.parent && node.parent.parent.kind === SyntaxKind.TypeLiteral)) {

Debug.assert(node.parent.kind === SyntaxKind.MethodDeclaration ||

node.parent.kind === SyntaxKind.MethodSignature ||

node.parent.kind === SyntaxKind.FunctionType ||

node.parent.kind === SyntaxKind.ConstructorType ||

node.parent.kind === SyntaxKind.CallSignature ||

node.parent.kind === SyntaxKind.ConstructSignature);

emitType(node.constraint);

}

else {

emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.constraint, getTypeParameterConstraintVisibilityError);

}

}

function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {

// Type parameter constraints are named by user so we should always be able to name it

var diagnosticMessage: DiagnosticMessage;

switch (node.parent.kind) {

case SyntaxKind.ClassDeclaration:

diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1;

break;

case SyntaxKind.InterfaceDeclaration:

diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1;

break;

case SyntaxKind.ConstructSignature:

diagnosticMessage = Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;

break;

case SyntaxKind.CallSignature:

diagnosticMessage = Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;

break;

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

if (node.parent.flags & NodeFlags.Static) {

diagnosticMessage = Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;

}

else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {

diagnosticMessage = Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;

}

else {

diagnosticMessage = Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;

}

break;

case SyntaxKind.FunctionDeclaration:

diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;

break;

default:

Debug.fail("This is unknown parent for type parameter: " + node.parent.kind);

}

return {

diagnosticMessage,

errorNode: node,

typeName: node.name

};

}

}

if (typeParameters) {

write("<");

emitCommaList(typeParameters, emitTypeParameter);

write(">");

}

}

function emitHeritageClause(typeReferences: TypeReferenceNode[], isImplementsList: boolean) {

if (typeReferences) {

write(isImplementsList ? " implements " : " extends ");

emitCommaList(typeReferences, emitTypeOfTypeReference);

}

function emitTypeOfTypeReference(node: TypeReferenceNode) {

emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);

function getHeritageClauseVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {

var diagnosticMessage: DiagnosticMessage;

// Heritage clause is written by user so it can always be named

if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {

// Class or Interface implemented/extended is inaccessible

diagnosticMessage = isImplementsList ?

Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 :

Diagnostics.Extends_clause_of_exported_class_0_has_or_is_using_private_name_1;

}

else {

// interface is inaccessible

diagnosticMessage = Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1;

}

return {

diagnosticMessage,

errorNode: node,

typeName: (<Declaration>node.parent.parent).name

};

}

}

}

function emitClassDeclaration(node: ClassDeclaration) {

function emitParameterProperties(constructorDeclaration: ConstructorDeclaration) {

if (constructorDeclaration) {

forEach(constructorDeclaration.parameters, param => {

if (param.flags & NodeFlags.AccessibilityModifier) {

emitPropertyDeclaration(param);

}

});

}

}

if (resolver.isDeclarationVisible(node)) {

emitJsDocComments(node);

emitModuleElementDeclarationFlags(node);

write("class ");

writeTextOfNode(currentSourceFile, node.name);

var prevEnclosingDeclaration = enclosingDeclaration;

enclosingDeclaration = node;

emitTypeParameters(node.typeParameters);

var baseTypeNode = getClassBaseTypeNode(node);

if (baseTypeNode) {

emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);

}

emitHeritageClause(getClassImplementedTypeNodes(node), /*isImplementsList*/ true);

write(" {");

writeLine();

increaseIndent();

emitParameterProperties(getFirstConstructorWithBody(node));

emitLines(node.members);

decreaseIndent();

write("}");

writeLine();

enclosingDeclaration = prevEnclosingDeclaration;

}

}

function emitInterfaceDeclaration(node: InterfaceDeclaration) {

if (resolver.isDeclarationVisible(node)) {

emitJsDocComments(node);

emitModuleElementDeclarationFlags(node);

write("interface ");

writeTextOfNode(currentSourceFile, node.name);

var prevEnclosingDeclaration = enclosingDeclaration;

enclosingDeclaration = node;

emitTypeParameters(node.typeParameters);

emitHeritageClause(getInterfaceBaseTypeNodes(node), /*isImplementsList*/ false);

write(" {");