node: Node;

outputPos: number;

indent: number;

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

subModuleElementDeclarationEmitInfo?: ModuleElementDeclarationEmitInfo[];

isVisible?: boolean;

reportedDeclarationError: boolean;

moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[];

synchronousDeclarationOutput: string;

referencePathsOutput: string;

errorNode: Node;

diagnosticMessage: DiagnosticMessage;

typeName?: DeclarationName;

let diagnostics: Diagnostic[] = [];

let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js");

emitDeclarations(host, resolver, diagnostics, jsFilePath, targetSourceFile);

return diagnostics;

let newLine = host.getNewLine();

let compilerOptions = host.getCompilerOptions();

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

let writeLine: () => void;

let increaseIndent: () => void;

let decreaseIndent: () => void;

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

let writer = createAndSetNewTextWriterWithSymbolWriter();

let enclosingDeclaration: Node;

let currentSourceFile: SourceFile;

let reportedDeclarationError = false;

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

let emit = compilerOptions.stripInternal ? stripInternal : emitNode;

let moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];

let asynchronousSubModuleDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[];

// 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

let referencePathsOutput = "";

if (root) {

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

if (!compilerOptions.noResolve) {

let addedGlobalFileReference = false;

forEach(root.referencedFiles, fileReference => {

let 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);

// create asynchronous output for the importDeclarations

if (moduleElementDeclarationEmitInfo.length) {

let oldWriter = writer;

forEach(moduleElementDeclarationEmitInfo, aliasEmitInfo => {

if (aliasEmitInfo.isVisible) {

Debug.assert(aliasEmitInfo.node.kind === SyntaxKind.ImportDeclaration);

createAndSetNewTextWriterWithSymbolWriter();

Debug.assert(aliasEmitInfo.indent === 0);

writeImportDeclaration(<ImportDeclaration>aliasEmitInfo.node);

aliasEmitInfo.asynchronousOutput = writer.getText();

}

});

setWriter(oldWriter);

}

}

else {

// Emit references corresponding to this file

let emittedReferencedFiles: SourceFile[] = [];

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

if (!isExternalModuleOrDeclarationFile(sourceFile)) {

// Check what references need to be added

if (!compilerOptions.noResolve) {

forEach(sourceFile.referencedFiles, fileReference => {

let 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,

moduleElementDeclarationEmitInfo,

synchronousDeclarationOutput: writer.getText(),

referencePathsOutput,

};

function hasInternalAnnotation(range: CommentRange) {

let text = currentSourceFile.text;

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

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

}

function stripInternal(node: Node) {

if (node) {

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

if (forEach(leadingCommentRanges, hasInternalAnnotation)) {

return;

}

emitNode(node);

}

}

function createAndSetNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {

let 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 writeAsynchronousModuleElements(nodes: Node[]) {

let oldWriter = writer;

forEach(nodes, declaration => {

let nodeToCheck: Node;

if (declaration.kind === SyntaxKind.VariableDeclaration) {

nodeToCheck = declaration.parent.parent;

} else if (declaration.kind === SyntaxKind.NamedImports || declaration.kind === SyntaxKind.ImportSpecifier || declaration.kind === SyntaxKind.ImportClause) {

Debug.fail("We should be getting ImportDeclaration instead to write");

} else {

nodeToCheck = declaration;

}

let moduleElementEmitInfo = forEach(moduleElementDeclarationEmitInfo, declEmitInfo => declEmitInfo.node === nodeToCheck ? declEmitInfo : undefined);

if (!moduleElementEmitInfo && asynchronousSubModuleDeclarationEmitInfo) {

moduleElementEmitInfo = forEach(asynchronousSubModuleDeclarationEmitInfo, declEmitInfo => declEmitInfo.node === nodeToCheck ? 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 (moduleElementEmitInfo) {

if (moduleElementEmitInfo.node.kind === SyntaxKind.ImportDeclaration) {

// we have to create asynchronous output only after we have collected complete information

// because it is possible to enable multiple bindings as asynchronously visible

moduleElementEmitInfo.isVisible = true;

}

else {

createAndSetNewTextWriterWithSymbolWriter();

for (let declarationIndent = moduleElementEmitInfo.indent; declarationIndent; declarationIndent--) {

increaseIndent();

}

if (nodeToCheck.kind === SyntaxKind.ModuleDeclaration) {

Debug.assert(asynchronousSubModuleDeclarationEmitInfo === undefined);

asynchronousSubModuleDeclarationEmitInfo = [];

}

writeModuleElement(nodeToCheck);

if (nodeToCheck.kind === SyntaxKind.ModuleDeclaration) {

moduleElementEmitInfo.subModuleElementDeclarationEmitInfo = asynchronousSubModuleDeclarationEmitInfo;

asynchronousSubModuleDeclarationEmitInfo = undefined;

}

moduleElementEmitInfo.asynchronousOutput = writer.getText();

}

}

});

setWriter(oldWriter);

}

function handleSymbolAccessibilityError(symbolAccesibilityResult: SymbolAccessiblityResult) {

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

// write the aliases

if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) {

writeAsynchronousModuleElements(symbolAccesibilityResult.aliasesToMakeVisible);

}

}

else {

// Report error

reportedDeclarationError = true;

let 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, 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 (let node of nodes) {

emit(node);

}

}

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

let currentWriterPos = writer.getTextPos();

for (let node of nodes) {

if (!canEmitFn || canEmitFn(node)) {

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

write(separator);

}

currentWriterPos = writer.getTextPos();

eachNodeEmitFn(node);

}

}

}

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

emitSeparatedList(nodes, ", ", eachNodeEmitFn, canEmitFn);

}

function writeJsDocComments(declaration: Node) {

if (declaration) {

let 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 | Identifier | QualifiedName) {

switch (type.kind) {

case SyntaxKind.AnyKeyword:

case SyntaxKind.StringKeyword:

case SyntaxKind.NumberKeyword:

case SyntaxKind.BooleanKeyword:

case SyntaxKind.SymbolKeyword:

case SyntaxKind.VoidKeyword:

case SyntaxKind.StringLiteral:

return writeTextOfNode(currentSourceFile, type);

case SyntaxKind.ExpressionWithTypeArguments:

return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>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.IntersectionType:

return emitIntersectionType(<IntersectionTypeNode>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);

case SyntaxKind.TypePredicate:

return emitTypePredicate(<TypePredicateNode>type);

}

function writeEntityName(entityName: EntityName | Expression) {

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

writeTextOfNode(currentSourceFile, entityName);

}

else {

let left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;

let right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;

writeEntityName(left);

write(".");

writeTextOfNode(currentSourceFile, right);

}

}

function emitEntityName(entityName: EntityName | PropertyAccessExpression) {

let visibilityResult = resolver.isEntityNameVisible(entityName,

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

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

handleSymbolAccessibilityError(visibilityResult);

writeEntityName(entityName);

}

function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {

if (isSupportedExpressionWithTypeArguments(node)) {

Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);

emitEntityName(<Identifier | PropertyAccessExpression>node.expression);

if (node.typeArguments) {

write("<");

emitCommaList(node.typeArguments, emitType);

write(">");

}

}

}

function emitTypeReference(type: TypeReferenceNode) {

emitEntityName(type.typeName);

if (type.typeArguments) {

write("<");

emitCommaList(type.typeArguments, emitType);

write(">");

}

}

function emitTypePredicate(type: TypePredicateNode) {

writeTextOfNode(currentSourceFile, type.parameterName);

write(" is ");

emitType(type.type);

}

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 emitIntersectionType(type: IntersectionTypeNode) {

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);

}

// Return a temp variable name to be used in `export default` statements.

// The temp name will be of the form _default_counter.

// Note that export default is only allowed at most once in a module, so we

// do not need to keep track of created temp names.

function getExportDefaultTempVariableName(): string {

let baseName = "_default";

if (!hasProperty(currentSourceFile.identifiers, baseName)) {

return baseName;

}

let count = 0;

while (true) {

let name = baseName + "_" + (++count);

if (!hasProperty(currentSourceFile.identifiers, name)) {

return name;

}

}

}

function emitExportAssignment(node: ExportAssignment) {

if (node.expression.kind === SyntaxKind.Identifier) {

write(node.isExportEquals ? "export = " : "export default ");

writeTextOfNode(currentSourceFile, node.expression);

}

else {

// Expression

let tempVarName = getExportDefaultTempVariableName();

write("declare var ");

write(tempVarName);

write(": ");

writer.getSymbolAccessibilityDiagnostic = getDefaultExportAccessibilityDiagnostic;

resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);

write(";");

writeLine();

write(node.isExportEquals ? "export = " : "export default ");

write(tempVarName);

}

write(";");

writeLine();

// Make all the declarations visible for the export name

if (node.expression.kind === SyntaxKind.Identifier) {

let nodes = resolver.collectLinkedAliases(<Identifier>node.expression);

// write each of these declarations asynchronously

writeAsynchronousModuleElements(nodes);

}

function getDefaultExportAccessibilityDiagnostic(diagnostic: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {

return {

diagnosticMessage: Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,

errorNode: node

};

}

}

function isModuleElementVisible(node: Declaration) {

return resolver.isDeclarationVisible(node);

}

function emitModuleElement(node: Node, isModuleElementVisible: boolean) {

if (isModuleElementVisible) {

writeModuleElement(node);

}

// Import equals declaration in internal module can become visible as part of any emit so lets make sure we add these irrespective

else if (node.kind === SyntaxKind.ImportEqualsDeclaration ||

(node.parent.kind === SyntaxKind.SourceFile && isExternalModule(currentSourceFile))) {

let isVisible: boolean;

if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== SyntaxKind.SourceFile) {

// Import declaration of another module that is visited async so lets put it in right spot

asynchronousSubModuleDeclarationEmitInfo.push({

node,

outputPos: writer.getTextPos(),

indent: writer.getIndent(),

isVisible

});

}

else {

if (node.kind === SyntaxKind.ImportDeclaration) {

let importDeclaration = <ImportDeclaration>node;

if (importDeclaration.importClause) {

isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) ||

isVisibleNamedBinding(importDeclaration.importClause.namedBindings);

}

}

moduleElementDeclarationEmitInfo.push({

node,

outputPos: writer.getTextPos(),

indent: writer.getIndent(),

isVisible

});

}

}

}

function writeModuleElement(node: Node) {

switch (node.kind) {

case SyntaxKind.FunctionDeclaration:

return writeFunctionDeclaration(<FunctionLikeDeclaration>node);

case SyntaxKind.VariableStatement:

return writeVariableStatement(<VariableStatement>node);

case SyntaxKind.InterfaceDeclaration:

return writeInterfaceDeclaration(<InterfaceDeclaration>node);

case SyntaxKind.ClassDeclaration:

return writeClassDeclaration(<ClassDeclaration>node);

case SyntaxKind.TypeAliasDeclaration:

return writeTypeAliasDeclaration(<TypeAliasDeclaration>node);

case SyntaxKind.EnumDeclaration:

return writeEnumDeclaration(<EnumDeclaration>node);

case SyntaxKind.ModuleDeclaration:

return writeModuleDeclaration(<ModuleDeclaration>node);

case SyntaxKind.ImportEqualsDeclaration:

return writeImportEqualsDeclaration(<ImportEqualsDeclaration>node);

case SyntaxKind.ImportDeclaration:

return writeImportDeclaration(<ImportDeclaration>node);

default:

Debug.fail("Unknown symbol kind");

}

}

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.flags & NodeFlags.Default) {

write("default ");

}

else 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 ");

}

if (node.flags & NodeFlags.Abstract) {

write("abstract ");

}

}

function writeImportEqualsDeclaration(node: ImportEqualsDeclaration) {

// 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 (isInternalModuleImportEqualsDeclaration(node)) {

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

write(";");

}

else {

write("require(");

writeTextOfNode(currentSourceFile, getExternalModuleImportEqualsDeclarationExpression(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 isVisibleNamedBinding(namedBindings: NamespaceImport | NamedImports): boolean {

if (namedBindings) {

if (namedBindings.kind === SyntaxKind.NamespaceImport) {

return resolver.isDeclarationVisible(<NamespaceImport>namedBindings);

}

else {

return forEach((<NamedImports>namedBindings).elements, namedImport => resolver.isDeclarationVisible(namedImport));

}

}

}

function writeImportDeclaration(node: ImportDeclaration) {

if (!node.importClause && !(node.flags & NodeFlags.Export)) {

// do not write non-exported import declarations that don't have import clauses

return;

}

emitJsDocComments(node);

if (node.flags & NodeFlags.Export) {

write("export ");

}

write("import ");

if (node.importClause) {

let currentWriterPos = writer.getTextPos();

if (node.importClause.name && resolver.isDeclarationVisible(node.importClause)) {

writeTextOfNode(currentSourceFile, node.importClause.name);

}

if (node.importClause.namedBindings && isVisibleNamedBinding(node.importClause.namedBindings)) {

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

// If the default binding was emitted, write the separated

write(", ");

}

if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {

write("* as ");

writeTextOfNode(currentSourceFile, (<NamespaceImport>node.importClause.namedBindings).name);

}

else {

write("{ ");

emitCommaList((<NamedImports>node.importClause.namedBindings).elements, emitImportOrExportSpecifier, resolver.isDeclarationVisible);

write(" }");

}

}

write(" from ");

}

writeTextOfNode(currentSourceFile, node.moduleSpecifier);

write(";");

writer.writeLine();

}

function emitImportOrExportSpecifier(node: ImportOrExportSpecifier) {

if (node.propertyName) {

writeTextOfNode(currentSourceFile, node.propertyName);

write(" as ");

}

writeTextOfNode(currentSourceFile, node.name);

}

function emitExportSpecifier(node: ExportSpecifier) {

emitImportOrExportSpecifier(node);

// Make all the declarations visible for the export name

let nodes = resolver.collectLinkedAliases(node.propertyName || node.name);

// write each of these declarations asynchronously

writeAsynchronousModuleElements(nodes);

}

function emitExportDeclaration(node: ExportDeclaration) {

emitJsDocComments(node);

write("export ");

if (node.exportClause) {

write("{ ");

emitCommaList(node.exportClause.elements, emitExportSpecifier);

write(" }");

}

else {

write("*");

}

if (node.moduleSpecifier) {

write(" from ");

writeTextOfNode(currentSourceFile, node.moduleSpecifier);

}

write(";");

writer.writeLine();

}

function writeModuleDeclaration(node: ModuleDeclaration) {

emitJsDocComments(node);

emitModuleElementDeclarationFlags(node);

if (node.flags & NodeFlags.Namespace) {

write("namespace ");

}

else {

write("module ");

}

writeTextOfNode(currentSourceFile, node.name);

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

node = <ModuleDeclaration>node.body;

write(".");

writeTextOfNode(currentSourceFile, node.name);

}

let prevEnclosingDeclaration = enclosingDeclaration;

enclosingDeclaration = node;

write(" {");

writeLine();

increaseIndent();

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

decreaseIndent();

write("}");

writeLine();

enclosingDeclaration = prevEnclosingDeclaration;

}

function writeTypeAliasDeclaration(node: TypeAliasDeclaration) {

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 writeEnumDeclaration(node: EnumDeclaration) {

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);

let 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);