/*@internal*/

namespace ts {

export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, file: SourceFile | undefined): DiagnosticWithLocation[] | undefined {

const compilerOptions = host.getCompilerOptions();

const result = transformNodes(resolver, host, factory, compilerOptions, file ? [file] : filter(host.getSourceFiles(), isSourceFileNotJson), [transformDeclarations], /*allowDtsFiles*/ false);

return result.diagnostics;

}

function hasInternalAnnotation(range: CommentRange, currentSourceFile: SourceFile) {

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

return stringContains(comment, "@internal");

}

export function isInternalDeclaration(node: Node, currentSourceFile: SourceFile) {

const parseTreeNode = getParseTreeNode(node);

if (parseTreeNode && parseTreeNode.kind === SyntaxKind.Parameter) {

const paramIdx = (parseTreeNode.parent as SignatureDeclaration).parameters.indexOf(parseTreeNode as ParameterDeclaration);

const previousSibling = paramIdx > 0 ? (parseTreeNode.parent as SignatureDeclaration).parameters[paramIdx - 1] : undefined;

const text = currentSourceFile.text;

const commentRanges = previousSibling

? concatenate(

// to handle

// ... parameters, /* @internal */

// public param: string

getTrailingCommentRanges(text, skipTrivia(text, previousSibling.end + 1, /* stopAfterLineBreak */ false, /* stopAtComments */ true)),

getLeadingCommentRanges(text, node.pos)

)

: getTrailingCommentRanges(text, skipTrivia(text, node.pos, /* stopAfterLineBreak */ false, /* stopAtComments */ true));

return commentRanges && commentRanges.length && hasInternalAnnotation(last(commentRanges), currentSourceFile);

}

const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, currentSourceFile);

return !!forEach(leadingCommentRanges, range => {

return hasInternalAnnotation(range, currentSourceFile);

});

}

const declarationEmitNodeBuilderFlags =

NodeBuilderFlags.MultilineObjectLiterals |

NodeBuilderFlags.WriteClassExpressionAsTypeLiteral |

NodeBuilderFlags.UseTypeOfFunction |

NodeBuilderFlags.UseStructuralFallback |

NodeBuilderFlags.AllowEmptyTuple |

NodeBuilderFlags.GenerateNamesForShadowedTypeParams |

NodeBuilderFlags.NoTruncation;

/**

* Transforms a ts file into a .d.ts file

* This process requires type information, which is retrieved through the emit resolver. Because of this,

* in many places this transformer assumes it will be operating on parse tree nodes directly.

* This means that _no transforms should be allowed to occur before this one_.

*/

export function transformDeclarations(context: TransformationContext) {

const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");

let getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic = throwDiagnostic;

let needsDeclare = true;

let isBundledEmit = false;

let resultHasExternalModuleIndicator = false;

let needsScopeFixMarker = false;

let resultHasScopeMarker = false;

let enclosingDeclaration: Node;

let necessaryTypeReferences: Set<string> | undefined;

let lateMarkedStatements: LateVisibilityPaintedStatement[] | undefined;

let lateStatementReplacementMap: ESMap<NodeId, VisitResult<LateVisibilityPaintedStatement | ExportAssignment>>;

let suppressNewDiagnosticContexts: boolean;

let exportedModulesFromDeclarationEmit: Symbol[] | undefined;

const { factory } = context;

const host = context.getEmitHost();

const symbolTracker: SymbolTracker = {

trackSymbol,

reportInaccessibleThisError,

reportInaccessibleUniqueSymbolError,

reportCyclicStructureError,

reportPrivateInBaseOfClassExpression,

reportLikelyUnsafeImportRequiredError,

reportTruncationError,

moduleResolverHost: host,

trackReferencedAmbientModule,

trackExternalModuleSymbolOfImportTypeNode,

reportNonlocalAugmentation,

reportNonSerializableProperty

};

let errorNameNode: DeclarationName | undefined;

let errorFallbackNode: Declaration | undefined;

let currentSourceFile: SourceFile;

let refs: ESMap<NodeId, SourceFile>;

let libs: ESMap<string, boolean>;

let emittedImports: readonly AnyImportSyntax[] | undefined; // must be declared in container so it can be `undefined` while transformer's first pass

const resolver = context.getEmitResolver();

const options = context.getCompilerOptions();

const { noResolve, stripInternal } = options;

return transformRoot;

function recordTypeReferenceDirectivesIfNecessary(typeReferenceDirectives: readonly string[] | undefined): void {

if (!typeReferenceDirectives) {

return;

}

necessaryTypeReferences = necessaryTypeReferences || new Set();

for (const ref of typeReferenceDirectives) {

necessaryTypeReferences.add(ref);

}

}

function trackReferencedAmbientModule(node: ModuleDeclaration, symbol: Symbol) {

// If it is visible via `// <reference types="..."/>`, then we should just use that

const directives = resolver.getTypeReferenceDirectivesForSymbol(symbol, SymbolFlags.All);

if (length(directives)) {

return recordTypeReferenceDirectivesIfNecessary(directives);

}

// Otherwise we should emit a path-based reference

const container = getSourceFileOfNode(node);

refs.set(getOriginalNodeId(container), container);

}

function handleSymbolAccessibilityError(symbolAccessibilityResult: SymbolAccessibilityResult) {

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

// Add aliases back onto the possible imports list if they're not there so we can try them again with updated visibility info

if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {

if (!lateMarkedStatements) {

lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible;

}

else {

for (const ref of symbolAccessibilityResult.aliasesToMakeVisible) {

pushIfUnique(lateMarkedStatements, ref);

}

}

}

// TODO: Do all these accessibility checks inside/after the first pass in the checker when declarations are enabled, if possible

}

else {

// Report error

const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);

if (errorInfo) {

if (errorInfo.typeName) {

context.addDiagnostic(createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode,

errorInfo.diagnosticMessage,

getTextOfNode(errorInfo.typeName),

symbolAccessibilityResult.errorSymbolName,

symbolAccessibilityResult.errorModuleName));

}

else {

context.addDiagnostic(createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode,

errorInfo.diagnosticMessage,

symbolAccessibilityResult.errorSymbolName,

symbolAccessibilityResult.errorModuleName));

}

return true;

}

}

return false;

}

function trackExternalModuleSymbolOfImportTypeNode(symbol: Symbol) {

if (!isBundledEmit) {

(exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol);

}

}

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

if (symbol.flags & SymbolFlags.TypeParameter) return false;

const issuedDiagnostic = handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ true));

recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));

return issuedDiagnostic;

}

function reportPrivateInBaseOfClassExpression(propertyName: string) {

if (errorNameNode || errorFallbackNode) {

context.addDiagnostic(

createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.Property_0_of_exported_class_expression_may_not_be_private_or_protected, propertyName));

}

}

function errorDeclarationNameWithFallback() {

return errorNameNode ? declarationNameToString(errorNameNode) :

errorFallbackNode && getNameOfDeclaration(errorFallbackNode) ? declarationNameToString(getNameOfDeclaration(errorFallbackNode)) :

errorFallbackNode && isExportAssignment(errorFallbackNode) ? errorFallbackNode.isExportEquals ? "export=" : "default" :

"(Missing)"; // same fallback declarationNameToString uses when node is zero-width (ie, nameless)

}

function reportInaccessibleUniqueSymbolError() {

if (errorNameNode || errorFallbackNode) {

context.addDiagnostic(createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary,

errorDeclarationNameWithFallback(),

"unique symbol"));

}

}

function reportCyclicStructureError() {

if (errorNameNode || errorFallbackNode) {

context.addDiagnostic(createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary,

errorDeclarationNameWithFallback()));

}

}

function reportInaccessibleThisError() {

if (errorNameNode || errorFallbackNode) {

context.addDiagnostic(createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary,

errorDeclarationNameWithFallback(),

"this"));

}

}

function reportLikelyUnsafeImportRequiredError(specifier: string) {

if (errorNameNode || errorFallbackNode) {

context.addDiagnostic(createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary,

errorDeclarationNameWithFallback(),

specifier));

}

}

function reportTruncationError() {

if (errorNameNode || errorFallbackNode) {

context.addDiagnostic(createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed));

}

}

function reportNonlocalAugmentation(containingFile: SourceFile, parentSymbol: Symbol, symbol: Symbol) {

const primaryDeclaration = parentSymbol.declarations?.find(d => getSourceFileOfNode(d) === containingFile)!;

const augmentingDeclarations = filter(symbol.declarations, d => getSourceFileOfNode(d) !== containingFile);

if (augmentingDeclarations) {

for (const augmentations of augmentingDeclarations) {

context.addDiagnostic(addRelatedInfo(

createDiagnosticForNode(augmentations, Diagnostics.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized),

createDiagnosticForNode(primaryDeclaration, Diagnostics.This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file)

));

}

}

}

function reportNonSerializableProperty(propertyName: string) {

if (errorNameNode || errorFallbackNode) {

context.addDiagnostic(createDiagnosticForNode((errorNameNode || errorFallbackNode)!, Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, propertyName));

}

}

function transformDeclarationsForJS(sourceFile: SourceFile, bundled?: boolean) {

const oldDiag = getSymbolAccessibilityDiagnostic;

getSymbolAccessibilityDiagnostic = (s) => (s.errorNode && canProduceDiagnostics(s.errorNode) ? createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : ({

diagnosticMessage: s.errorModuleName

? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit

: Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,

errorNode: s.errorNode || sourceFile

}));

const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled);

getSymbolAccessibilityDiagnostic = oldDiag;

return result;

}

function transformRoot(node: Bundle): Bundle;

function transformRoot(node: SourceFile): SourceFile;

function transformRoot(node: SourceFile | Bundle): SourceFile | Bundle;

function transformRoot(node: SourceFile | Bundle) {

if (node.kind === SyntaxKind.SourceFile && node.isDeclarationFile) {

return node;

}

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

isBundledEmit = true;

refs = new Map();

libs = new Map();

let hasNoDefaultLib = false;

const bundle = factory.createBundle(map(node.sourceFiles,

sourceFile => {

if (sourceFile.isDeclarationFile) return undefined!; // Omit declaration files from bundle results, too // TODO: GH#18217

hasNoDefaultLib = hasNoDefaultLib || sourceFile.hasNoDefaultLib;

currentSourceFile = sourceFile;

enclosingDeclaration = sourceFile;

lateMarkedStatements = undefined;

suppressNewDiagnosticContexts = false;

lateStatementReplacementMap = new Map();

getSymbolAccessibilityDiagnostic = throwDiagnostic;

needsScopeFixMarker = false;

resultHasScopeMarker = false;

collectReferences(sourceFile, refs);

collectLibs(sourceFile, libs);

if (isExternalOrCommonJsModule(sourceFile) || isJsonSourceFile(sourceFile)) {

resultHasExternalModuleIndicator = false; // unused in external module bundle emit (all external modules are within module blocks, therefore are known to be modules)

needsDeclare = false;

const statements = isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile, /*bundled*/ true)) : visitNodes(sourceFile.statements, visitDeclarationStatements);

const newFile = factory.updateSourceFile(sourceFile, [factory.createModuleDeclaration(

[],

[factory.createModifier(SyntaxKind.DeclareKeyword)],

factory.createStringLiteral(getResolvedExternalModuleName(context.getEmitHost(), sourceFile)),

factory.createModuleBlock(setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements))

)], /*isDeclarationFile*/ true, /*referencedFiles*/ [], /*typeReferences*/ [], /*hasNoDefaultLib*/ false, /*libReferences*/ []);

return newFile;

}

needsDeclare = true;

const updated = isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes(sourceFile.statements, visitDeclarationStatements);

return factory.updateSourceFile(sourceFile, transformAndReplaceLatePaintedStatements(updated), /*isDeclarationFile*/ true, /*referencedFiles*/ [], /*typeReferences*/ [], /*hasNoDefaultLib*/ false, /*libReferences*/ []);

}

), mapDefined(node.prepends, prepend => {

if (prepend.kind === SyntaxKind.InputFiles) {

const sourceFile = createUnparsedSourceFile(prepend, "dts", stripInternal);

hasNoDefaultLib = hasNoDefaultLib || !!sourceFile.hasNoDefaultLib;

collectReferences(sourceFile, refs);

recordTypeReferenceDirectivesIfNecessary(sourceFile.typeReferenceDirectives);

collectLibs(sourceFile, libs);

return sourceFile;

}

return prepend;

}));

bundle.syntheticFileReferences = [];

bundle.syntheticTypeReferences = getFileReferencesForUsedTypeReferences();

bundle.syntheticLibReferences = getLibReferences();

bundle.hasNoDefaultLib = hasNoDefaultLib;

const outputFilePath = getDirectoryPath(normalizeSlashes(getOutputPathsFor(node, host, /*forceDtsPaths*/ true).declarationFilePath!));

const referenceVisitor = mapReferencesIntoArray(bundle.syntheticFileReferences as FileReference[], outputFilePath);

refs.forEach(referenceVisitor);

return bundle;

}

// Single source file

needsDeclare = true;

needsScopeFixMarker = false;

resultHasScopeMarker = false;

enclosingDeclaration = node;

currentSourceFile = node;

getSymbolAccessibilityDiagnostic = throwDiagnostic;

isBundledEmit = false;

resultHasExternalModuleIndicator = false;

suppressNewDiagnosticContexts = false;

lateMarkedStatements = undefined;

lateStatementReplacementMap = new Map();

necessaryTypeReferences = undefined;

refs = collectReferences(currentSourceFile, new Map());

libs = collectLibs(currentSourceFile, new Map());

const references: FileReference[] = [];

const outputFilePath = getDirectoryPath(normalizeSlashes(getOutputPathsFor(node, host, /*forceDtsPaths*/ true).declarationFilePath!));

const referenceVisitor = mapReferencesIntoArray(references, outputFilePath);

let combinedStatements: NodeArray<Statement>;

if (isSourceFileJS(currentSourceFile)) {

combinedStatements = factory.createNodeArray(transformDeclarationsForJS(node));

refs.forEach(referenceVisitor);

emittedImports = filter(combinedStatements, isAnyImportSyntax);

}

else {

const statements = visitNodes(node.statements, visitDeclarationStatements);

combinedStatements = setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements);

refs.forEach(referenceVisitor);

emittedImports = filter(combinedStatements, isAnyImportSyntax);

if (isExternalModule(node) && (!resultHasExternalModuleIndicator || (needsScopeFixMarker && !resultHasScopeMarker))) {

combinedStatements = setTextRange(factory.createNodeArray([...combinedStatements, createEmptyExports(factory)]), combinedStatements);

}

}

const updated = factory.updateSourceFile(node, combinedStatements, /*isDeclarationFile*/ true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences());

updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit;

return updated;

function getLibReferences() {

return map(arrayFrom(libs.keys()), lib => ({ fileName: lib, pos: -1, end: -1 }));

}

function getFileReferencesForUsedTypeReferences() {

return necessaryTypeReferences ? mapDefined(arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForTypeName) : [];

}

function getFileReferenceForTypeName(typeName: string): FileReference | undefined {

// Elide type references for which we have imports

if (emittedImports) {

for (const importStatement of emittedImports) {

if (isImportEqualsDeclaration(importStatement) && isExternalModuleReference(importStatement.moduleReference)) {

const expr = importStatement.moduleReference.expression;

if (isStringLiteralLike(expr) && expr.text === typeName) {

return undefined;

}

}

else if (isImportDeclaration(importStatement) && isStringLiteral(importStatement.moduleSpecifier) && importStatement.moduleSpecifier.text === typeName) {

return undefined;

}

}

}

return { fileName: typeName, pos: -1, end: -1 };

}

function mapReferencesIntoArray(references: FileReference[], outputFilePath: string): (file: SourceFile) => void {

return file => {

let declFileName: string;

if (file.isDeclarationFile) { // Neither decl files or js should have their refs changed

declFileName = file.fileName;

}

else {

if (isBundledEmit && contains((node as Bundle).sourceFiles, file)) return; // Omit references to files which are being merged

const paths = getOutputPathsFor(file, host, /*forceDtsPaths*/ true);

declFileName = paths.declarationFilePath || paths.jsFilePath || file.fileName;

}

if (declFileName) {

const specifier = moduleSpecifiers.getModuleSpecifier(

options,

currentSourceFile,

toPath(outputFilePath, host.getCurrentDirectory(), host.getCanonicalFileName),

toPath(declFileName, host.getCurrentDirectory(), host.getCanonicalFileName),

host,

);

if (!pathIsRelative(specifier)) {

// If some compiler option/symlink/whatever allows access to the file containing the ambient module declaration

// via a non-relative name, emit a type reference directive to that non-relative name, rather than

// a relative path to the declaration file

recordTypeReferenceDirectivesIfNecessary([specifier]);

return;

}

let fileName = getRelativePathToDirectoryOrUrl(

outputFilePath,

declFileName,

host.getCurrentDirectory(),

host.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ false

);

if (startsWith(fileName, "./") && hasExtension(fileName)) {

fileName = fileName.substring(2);

}

// omit references to files from node_modules (npm may disambiguate module

// references when installing this package, making the path is unreliable).

if (startsWith(fileName, "node_modules/") || pathContainsNodeModules(fileName)) {

return;

}

references.push({ pos: -1, end: -1, fileName });

}

};

}

}

function collectReferences(sourceFile: SourceFile | UnparsedSource, ret: ESMap<NodeId, SourceFile>) {

if (noResolve || (!isUnparsedSource(sourceFile) && isSourceFileJS(sourceFile))) return ret;

forEach(sourceFile.referencedFiles, f => {

const elem = host.getSourceFileFromReference(sourceFile, f);

if (elem) {

ret.set(getOriginalNodeId(elem), elem);

}

});

return ret;

}

function collectLibs(sourceFile: SourceFile | UnparsedSource, ret: ESMap<string, boolean>) {

forEach(sourceFile.libReferenceDirectives, ref => {

const lib = host.getLibFileFromReference(ref);

if (lib) {

ret.set(toFileNameLowerCase(ref.fileName), true);

}

});

return ret;

}

function filterBindingPatternInitializers(name: BindingName) {

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

return name;

}

else {

if (name.kind === SyntaxKind.ArrayBindingPattern) {

return factory.updateArrayBindingPattern(name, visitNodes(name.elements, visitBindingElement));

}

else {

return factory.updateObjectBindingPattern(name, visitNodes(name.elements, visitBindingElement));

}

}

function visitBindingElement<T extends ArrayBindingElement>(elem: T): T;

function visitBindingElement(elem: ArrayBindingElement): ArrayBindingElement {

if (elem.kind === SyntaxKind.OmittedExpression) {

return elem;

}

return factory.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializers(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined);

}

}

function ensureParameter(p: ParameterDeclaration, modifierMask?: ModifierFlags, type?: TypeNode): ParameterDeclaration {

let oldDiag: typeof getSymbolAccessibilityDiagnostic | undefined;

if (!suppressNewDiagnosticContexts) {

oldDiag = getSymbolAccessibilityDiagnostic;

getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p);

}

const newParam = factory.updateParameterDeclaration(

p,

/*decorators*/ undefined,

maskModifiers(p, modifierMask),

p.dotDotDotToken,

filterBindingPatternInitializers(p.name),

resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(SyntaxKind.QuestionToken)) : undefined,

ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param

ensureNoInitializer(p)

);

if (!suppressNewDiagnosticContexts) {

getSymbolAccessibilityDiagnostic = oldDiag!;

}

return newParam;

}

function shouldPrintWithInitializer(node: Node) {

return canHaveLiteralInitializer(node) && resolver.isLiteralConstDeclaration(getParseTreeNode(node) as CanHaveLiteralInitializer); // TODO: Make safe

}

function ensureNoInitializer(node: CanHaveLiteralInitializer) {

if (shouldPrintWithInitializer(node)) {

return resolver.createLiteralConstValue(getParseTreeNode(node) as CanHaveLiteralInitializer, symbolTracker); // TODO: Make safe

}

return undefined;

}

type HasInferredType =

| FunctionDeclaration

| MethodDeclaration

| GetAccessorDeclaration

| SetAccessorDeclaration

| BindingElement

| ConstructSignatureDeclaration

| VariableDeclaration

| MethodSignature

| CallSignatureDeclaration

| ParameterDeclaration

| PropertyDeclaration

| PropertySignature;

function ensureType(node: HasInferredType, type: TypeNode | undefined, ignorePrivate?: boolean): TypeNode | undefined {

if (!ignorePrivate && hasEffectiveModifier(node, ModifierFlags.Private)) {

// Private nodes emit no types (except private parameter properties, whose parameter types are actually visible)

return;

}

if (shouldPrintWithInitializer(node)) {

// Literal const declarations will have an initializer ensured rather than a type

return;

}

const shouldUseResolverType = node.kind === SyntaxKind.Parameter &&

(resolver.isRequiredInitializedParameter(node) ||

resolver.isOptionalUninitializedParameterProperty(node));

if (type && !shouldUseResolverType) {

return visitNode(type, visitDeclarationSubtree);

}

if (!getParseTreeNode(node)) {

return type ? visitNode(type, visitDeclarationSubtree) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);

}

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

// Set accessors with no associated type node (from it's param or get accessor return) are `any` since they are never contextually typed right now

// (The inferred type here will be void, but the old declaration emitter printed `any`, so this replicates that)

return factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);

}

errorNameNode = node.name;

let oldDiag: typeof getSymbolAccessibilityDiagnostic;

if (!suppressNewDiagnosticContexts) {

oldDiag = getSymbolAccessibilityDiagnostic;

getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);

}

if (node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.BindingElement) {

return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));

}

if (node.kind === SyntaxKind.Parameter

|| node.kind === SyntaxKind.PropertyDeclaration

|| node.kind === SyntaxKind.PropertySignature) {

if (!node.initializer) return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));

return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));

}

return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));

function cleanup(returnValue: TypeNode | undefined) {

errorNameNode = undefined;

if (!suppressNewDiagnosticContexts) {

getSymbolAccessibilityDiagnostic = oldDiag;

}

return returnValue || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);

}

}

function isDeclarationAndNotVisible(node: NamedDeclaration) {

node = getParseTreeNode(node) as NamedDeclaration;

switch (node.kind) {

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.EnumDeclaration:

return !resolver.isDeclarationVisible(node);

// The following should be doing their own visibility checks based on filtering their members

case SyntaxKind.VariableDeclaration:

return !getBindingNameVisible(node as VariableDeclaration);

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ExportDeclaration:

case SyntaxKind.ExportAssignment:

return false;

case SyntaxKind.ClassStaticBlockDeclaration:

return true;

}

return false;

}

// If the ExpandoFunctionDeclaration have multiple overloads, then we only need to emit properties for the last one.

function shouldEmitFunctionProperties(input: FunctionDeclaration) {

if (input.body) {

return true;

}

const overloadSignatures = input.symbol.declarations?.filter(decl => isFunctionDeclaration(decl) && !decl.body);

return !overloadSignatures || overloadSignatures.indexOf(input) === overloadSignatures.length - 1;

}

function getBindingNameVisible(elem: BindingElement | VariableDeclaration | OmittedExpression): boolean {

if (isOmittedExpression(elem)) {

return false;

}

if (isBindingPattern(elem.name)) {

// If any child binding pattern element has been marked visible (usually by collect linked aliases), then this is visible

return some(elem.name.elements, getBindingNameVisible);

}

else {

return resolver.isDeclarationVisible(elem);

}

}

function updateParamsList(node: Node, params: NodeArray<ParameterDeclaration>, modifierMask?: ModifierFlags) {

if (hasEffectiveModifier(node, ModifierFlags.Private)) {

return undefined!; // TODO: GH#18217

}

const newParams = map(params, p => ensureParameter(p, modifierMask));

if (!newParams) {

return undefined!; // TODO: GH#18217

}

return factory.createNodeArray(newParams, params.hasTrailingComma);

}

function updateAccessorParamsList(input: AccessorDeclaration, isPrivate: boolean) {

let newParams: ParameterDeclaration[] | undefined;

if (!isPrivate) {

const thisParameter = getThisParameter(input);

if (thisParameter) {

newParams = [ensureParameter(thisParameter)];

}

}

if (isSetAccessorDeclaration(input)) {

let newValueParameter: ParameterDeclaration | undefined;

if (!isPrivate) {

const valueParameter = getSetAccessorValueParameter(input);

if (valueParameter) {

const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));

newValueParameter = ensureParameter(valueParameter, /*modifierMask*/ undefined, accessorType);

}

}

if (!newValueParameter) {

newValueParameter = factory.createParameterDeclaration(

/*decorators*/ undefined,

/*modifiers*/ undefined,

/*dotDotDotToken*/ undefined,

"value"

);

}

newParams = append(newParams, newValueParameter);

}

return factory.createNodeArray(newParams || emptyArray);

}

function ensureTypeParams(node: Node, params: NodeArray<TypeParameterDeclaration> | undefined) {

return hasEffectiveModifier(node, ModifierFlags.Private) ? undefined : visitNodes(params, visitDeclarationSubtree);

}

function isEnclosingDeclaration(node: Node) {

return isSourceFile(node)

|| isTypeAliasDeclaration(node)

|| isModuleDeclaration(node)

|| isClassDeclaration(node)

|| isInterfaceDeclaration(node)

|| isFunctionLike(node)

|| isIndexSignatureDeclaration(node)

|| isMappedTypeNode(node);

}

function checkEntityNameVisibility(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node) {

const visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration);

handleSymbolAccessibilityError(visibilityResult);

recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName));

}

function preserveJsDoc<T extends Node>(updated: T, original: Node): T {

if (hasJSDocNodes(updated) && hasJSDocNodes(original)) {

updated.jsDoc = original.jsDoc;

}

return setCommentRange(updated, getCommentRange(original));

}

function rewriteModuleSpecifier<T extends Node>(parent: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration | ModuleDeclaration | ImportTypeNode, input: T | undefined): T | StringLiteral {

if (!input) return undefined!; // TODO: GH#18217

resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || (parent.kind !== SyntaxKind.ModuleDeclaration && parent.kind !== SyntaxKind.ImportType);

if (isStringLiteralLike(input)) {

if (isBundledEmit) {

const newName = getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent);

if (newName) {

return factory.createStringLiteral(newName);

}

}

else {

const symbol = resolver.getSymbolOfExternalModuleSpecifier(input);

if (symbol) {

(exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol);

}

}

}

return input;

}

function transformImportEqualsDeclaration(decl: ImportEqualsDeclaration) {

if (!resolver.isDeclarationVisible(decl)) return;

if (decl.moduleReference.kind === SyntaxKind.ExternalModuleReference) {

// Rewrite external module names if necessary

const specifier = getExternalModuleImportEqualsDeclarationExpression(decl);

return factory.updateImportEqualsDeclaration(

decl,

/*decorators*/ undefined,

decl.modifiers,

decl.isTypeOnly,

decl.name,

factory.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))

);

}

else {

const oldDiag = getSymbolAccessibilityDiagnostic;

getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(decl);

checkEntityNameVisibility(decl.moduleReference, enclosingDeclaration);

getSymbolAccessibilityDiagnostic = oldDiag;

return decl;

}

}

function transformImportDeclaration(decl: ImportDeclaration) {

if (!decl.importClause) {

// import "mod" - possibly needed for side effects? (global interface patches, module augmentations, etc)

return factory.updateImportDeclaration(

decl,

/*decorators*/ undefined,

decl.modifiers,

decl.importClause,

rewriteModuleSpecifier(decl, decl.moduleSpecifier),

/*assertClause*/ undefined

);

}

// The `importClause` visibility corresponds to the default's visibility.

const visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : undefined;

if (!decl.importClause.namedBindings) {

// No named bindings (either namespace or list), meaning the import is just default or should be elided

return visibleDefaultBinding && factory.updateImportDeclaration(decl, /*decorators*/ undefined, decl.modifiers, factory.updateImportClause(

decl.importClause,

decl.importClause.isTypeOnly,

visibleDefaultBinding,

/*namedBindings*/ undefined,

), rewriteModuleSpecifier(decl, decl.moduleSpecifier), /*assertClause*/ undefined);

}

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

// Namespace import (optionally with visible default)

const namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : /*namedBindings*/ undefined;

return visibleDefaultBinding || namedBindings ? factory.updateImportDeclaration(decl, /*decorators*/ undefined, decl.modifiers, factory.updateImportClause(

decl.importClause,

decl.importClause.isTypeOnly,

visibleDefaultBinding,

namedBindings,

), rewriteModuleSpecifier(decl, decl.moduleSpecifier), /*assertClause*/ undefined) : undefined;

}

// Named imports (optionally with visible default)

const bindingList = mapDefined(decl.importClause.namedBindings.elements, b => resolver.isDeclarationVisible(b) ? b : undefined);

if ((bindingList && bindingList.length) || visibleDefaultBinding) {

return factory.updateImportDeclaration(

decl,

/*decorators*/ undefined,

decl.modifiers,

factory.updateImportClause(

decl.importClause,

decl.importClause.isTypeOnly,

visibleDefaultBinding,

bindingList && bindingList.length ? factory.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined,

),

rewriteModuleSpecifier(decl, decl.moduleSpecifier),

/*assertClause*/ undefined

);

}

// Augmentation of export depends on import

if (resolver.isImportRequiredByAugmentation(decl)) {

return factory.updateImportDeclaration(

decl,

/*decorators*/ undefined,

decl.modifiers,

/*importClause*/ undefined,

rewriteModuleSpecifier(decl, decl.moduleSpecifier),

/*assertClause*/ undefined

);

}

// Nothing visible

}

function transformAndReplaceLatePaintedStatements(statements: NodeArray<Statement>): NodeArray<Statement> {

// This is a `while` loop because `handleSymbolAccessibilityError` can see additional import aliases marked as visible during

// error handling which must now be included in the output and themselves checked for errors.

// For example:

// ```

// module A {

// export module Q {}

// import B = Q;

// import C = B;

// export import D = C;

// }

// ```

// In such a scenario, only Q and D are initially visible, but we don't consider imports as private names - instead we say they if they are referenced they must

// be recorded. So while checking D's visibility we mark C as visible, then we must check C which in turn marks B, completing the chain of

// dependent imports and allowing a valid declaration file output. Today, this dependent alias marking only happens for internal import aliases.

while (length(lateMarkedStatements)) {

const i = lateMarkedStatements!.shift()!;

if (!isLateVisibilityPaintedStatement(i)) {

return Debug.fail(`Late replaced statement was found which is not handled by the declaration transformer!: ${(ts as any).SyntaxKind ? (ts as any).SyntaxKind[(i as any).kind] : (i as any).kind}`);

}

const priorNeedsDeclare = needsDeclare;

needsDeclare = i.parent && isSourceFile(i.parent) && !(isExternalModule(i.parent) && isBundledEmit);

const result = transformTopLevelDeclaration(i);

needsDeclare = priorNeedsDeclare;

lateStatementReplacementMap.set(getOriginalNodeId(i), result);

}

// And lastly, we need to get the final form of all those indetermine import declarations from before and add them to the output list

// (and remove them from the set to examine for outter declarations)

return visitNodes(statements, visitLateVisibilityMarkedStatements);

function visitLateVisibilityMarkedStatements(statement: Statement) {

if (isLateVisibilityPaintedStatement(statement)) {

const key = getOriginalNodeId(statement);

if (lateStatementReplacementMap.has(key)) {

const result = lateStatementReplacementMap.get(key);

lateStatementReplacementMap.delete(key);

if (result) {

if (isArray(result) ? some(result, needsScopeMarker) : needsScopeMarker(result)) {

// Top-level declarations in .d.ts files are always considered exported even without a modifier unless there's an export assignment or specifier

needsScopeFixMarker = true;

}

if (isSourceFile(statement.parent) && (isArray(result) ? some(result, isExternalModuleIndicator) : isExternalModuleIndicator(result))) {

resultHasExternalModuleIndicator = true;

}

}

return result;

}

}

return statement;

}

}

function visitDeclarationSubtree(input: Node): VisitResult<Node> {

if (shouldStripInternal(input)) return;

if (isDeclaration(input)) {

if (isDeclarationAndNotVisible(input)) return;

if (hasDynamicName(input) && !resolver.isLateBound(getParseTreeNode(input) as Declaration)) {

return;

}

}

// Elide implementation signatures from overload sets

if (isFunctionLike(input) && resolver.isImplementationOfOverload(input)) return;

// Elide semicolon class statements

if (isSemicolonClassElement(input)) return;

let previousEnclosingDeclaration: typeof enclosingDeclaration;

if (isEnclosingDeclaration(input)) {

previousEnclosingDeclaration = enclosingDeclaration;

enclosingDeclaration = input as Declaration;

}

const oldDiag = getSymbolAccessibilityDiagnostic;

// Setup diagnostic-related flags before first potential `cleanup` call, otherwise

// We'd see a TDZ violation at runtime

const canProduceDiagnostic = canProduceDiagnostics(input);

const oldWithinObjectLiteralType = suppressNewDiagnosticContexts;

let shouldEnterSuppressNewDiagnosticsContextContext = ((input.kind === SyntaxKind.TypeLiteral || input.kind === SyntaxKind.MappedType) && input.parent.kind !== SyntaxKind.TypeAliasDeclaration);

// Emit methods which are private as properties with no type information

if (isMethodDeclaration(input) || isMethodSignature(input)) {

if (hasEffectiveModifier(input, ModifierFlags.Private)) {

if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input) return; // Elide all but the first overload

return cleanup(factory.createPropertyDeclaration(/*decorators*/ undefined, ensureModifiers(input), input.name, /*questionToken*/ undefined, /*type*/ undefined, /*initializer*/ undefined));

}

}

if (canProduceDiagnostic && !suppressNewDiagnosticContexts) {

getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(input as DeclarationDiagnosticProducing);

}

if (isTypeQueryNode(input)) {

checkEntityNameVisibility(input.exprName, enclosingDeclaration);

}

if (shouldEnterSuppressNewDiagnosticsContextContext) {

// We stop making new diagnostic contexts within object literal types. Unless it's an object type on the RHS of a type alias declaration. Then we do.

suppressNewDiagnosticContexts = true;

}

if (isProcessedComponent(input)) {

switch (input.kind) {

case SyntaxKind.ExpressionWithTypeArguments: {

if ((isEntityName(input.expression) || isEntityNameExpression(input.expression))) {

checkEntityNameVisibility(input.expression, enclosingDeclaration);

}

const node = visitEachChild(input, visitDeclarationSubtree, context);

return cleanup(factory.updateExpressionWithTypeArguments(node, node.expression, node.typeArguments));

}

case SyntaxKind.TypeReference: {

checkEntityNameVisibility(input.typeName, enclosingDeclaration);

const node = visitEachChild(input, visitDeclarationSubtree, context);

return cleanup(factory.updateTypeReferenceNode(node, node.typeName, node.typeArguments));

}

case SyntaxKind.ConstructSignature:

return cleanup(factory.updateConstructSignature(

input,

ensureTypeParams(input, input.typeParameters),

updateParamsList(input, input.parameters),

ensureType(input, input.type)

));

case SyntaxKind.Constructor: {

// A constructor declaration may not have a type annotation

const ctor = factory.createConstructorDeclaration(

/*decorators*/ undefined,

/*modifiers*/ ensureModifiers(input),

updateParamsList(input, input.parameters, ModifierFlags.None),

/*body*/ undefined

);

return cleanup(ctor);

}

case SyntaxKind.MethodDeclaration: {

if (isPrivateIdentifier(input.name)) {

return cleanup(/*returnValue*/ undefined);

}

const sig = factory.createMethodDeclaration(

/*decorators*/ undefined,

ensureModifiers(input),

/*asteriskToken*/ undefined,

input.name,

input.questionToken,

ensureTypeParams(input, input.typeParameters),

updateParamsList(input, input.parameters),

ensureType(input, input.type),

/*body*/ undefined

);

return cleanup(sig);

}

case SyntaxKind.GetAccessor: {

if (isPrivateIdentifier(input.name)) {

return cleanup(/*returnValue*/ undefined);

}

const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));

return cleanup(factory.updateGetAccessorDeclaration(

input,

/*decorators*/ undefined,

ensureModifiers(input),

input.name,

updateAccessorParamsList(input, hasEffectiveModifier(input, ModifierFlags.Private)),

ensureType(input, accessorType),

/*body*/ undefined));

}

case SyntaxKind.SetAccessor: {

if (isPrivateIdentifier(input.name)) {

return cleanup(/*returnValue*/ undefined);

}

return cleanup(factory.updateSetAccessorDeclaration(

input,

/*decorators*/ undefined,

ensureModifiers(input),

input.name,

updateAccessorParamsList(input, hasEffectiveModifier(input, ModifierFlags.Private)),

/*body*/ undefined));

}

case SyntaxKind.PropertyDeclaration:

if (isPrivateIdentifier(input.name)) {

return cleanup(/*returnValue*/ undefined);

}

return cleanup(factory.updatePropertyDeclaration(

input,

/*decorators*/ undefined,

ensureModifiers(input),

input.name,

input.questionToken,

ensureType(input, input.type),

ensureNoInitializer(input)

));

case SyntaxKind.PropertySignature:

if (isPrivateIdentifier(input.name)) {

return cleanup(/*returnValue*/ undefined);

}

return cleanup(factory.updatePropertySignature(

input,

ensureModifiers(input),

input.name,

input.questionToken,

ensureType(input, input.type)

));

case SyntaxKind.MethodSignature: {

if (isPrivateIdentifier(input.name)) {

return cleanup(/*returnValue*/ undefined);

}

return cleanup(factory.updateMethodSignature(

input,

ensureModifiers(input),

input.name,

input.questionToken,

ensureTypeParams(input, input.typeParameters),