Incorrect namespaces in externs when non-ambient declarations are imported

[theseanl]

When non-ambient declarations in a module .d.ts file is imported and referenced by another .d.ts, it will have an incorrect name.

Here is a repro: https://github.com/theseanl/tsickle-ambient-externs-bug: execute node invoke_tsickle.js to generate externs.js, then its line 46 contains an identifier that is nowhere defined.

[mprobst]

Not sure if that's relevant to your example, but here: https://github.com/theseanl/tsickle-ambient-externs-bug/blob/master/types/types.d.ts#L5 All types are ambient in the file, due to being in a .d.ts, right?

[theseanl]

By "ambient" I was just referring to the fact that isAmbient is returning true. In that file, only the declarations marked with declare keyword is treated as ambient.

[theseanl]

@mprobst Maybe then the isAmbient function is not returning what is intended?

It seems that SourceFile nodes do not contian the ts.ModifierFlags.Ambient modifier, in fact on my end it seems to have none, so if a node is not explicitly marked with declare keyword, isAmbient will return false for such a node.

In view of this, it seems to me that we don't need a conditional clause here https://github.com/angular/tsickle/blob/master/src/externs.ts#L629 that checks whether a node is ambient or not. If it belongs to a .d.ts file, then everything is "ambient", and otherwise we are checking ambient-ness at https://github.com/angular/tsickle/blob/master/src/externs.ts#L208 .

Moreover, it is invalid to use a value returned from host.pathToModuleName directly as an alias name here at https://github.com/angular/tsickle/blob/master/src/externs.ts#L632, because types of module names are different from identifiers and I guess that's why there is a moduleNameAsIdentifier function.

Thus removing isAmbientModuleDeclaration check and leaving only the branch with the moduleNameAsIdentifier call looks like what should be done and it fixes the issue on my end.

[mprobst]

If I remember correctly, the `if (isAmbientModuleDeclaration) {` handles the case that somebody might import a non-ambient symbol into an ambient module. I.e. the symbol used here is or might be from a different module. Imagine I have `a.ts` that has a regular declaration of `X`, and `b.d.ts` that imports `X` from `a.ts`. If the original declaration of `X` was ambient, than we (apparently) mangled its file name using `moduleNameAsIdentifier`, if it's non-ambient then we need to use `host.pathToModuleName`. Now I do not recall *why* exactly we have that difference in name mangling. I'd hope there's a test case for it.

[theseanl]

Hm, I'm not sure if I understand the situation you've describe correctly. I've tried to look up for a similar test case but couldn't find one -- could you elaborate?

So, there is a goog.module

goog.module('a.b.c'); // <---- module name produced by host.pathToModuleName

function A() { };
/** @type {number} */
A.prototype.prop;

or something, which contains a regular code which defines a class, for example.
And this is referenced in an externs file like this

/** @externs */
/**
 * @param {a.b.c.A} x  <------- this is what the non-ambient branch produces, using host.pathToModuleName
 * @return {*}
 */
some_function = function(x) { }

Does this actually work in closure compiler? I thought one needs goog.declareLegacyNamespace for something like this to work, which tsickle does not generate.

In addition, if someone imports a non-ambient type declaration (that is, without declare keyword) in a .d.ts file, then it will not be referred as goog.module.path.plus.local.name and instead it will always be ?, because of this line

tsickle/src/type_translator.ts

Line 427 in 0a0b1b5

if (this.isForExterns && isModule && !isAmbient) return '?';

If the type declaration was ambient then it will be included in externs and there will be alias names, so there is no issue.

These considerations make me inclined to think that there is no case that is relevant to the described situation, but this could be wrong. When I simply change lines

tsickle/src/externs.ts

Lines 632 to 633 in 0a0b1b5

	aliasName = host.pathToModuleName(
	sourceFile.fileName, resolveModuleName(host, sourceFile.fileName, fullUri));

to

aliasName = moduleNameAsIdentifier(host, resolveModuleName(host, sourceFile.fileName, fullUri));

(I haven't check that this does not do the same operation twice, but it gets the right result)
then e2e_test, golden_test, unit_test still passes. I can't locally check closure_e2e_test because it was anyway failing with an error

error message

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by com.google.protobuf.UnsafeUtil (file:...) to field java.nio.Buffer.address
WARNING: Please consider reporting this to the maintainers of com.google.protobuf.UnsafeUtil
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release