Static Methods Are Dropped On Externalised Interfaces

The compiler wouldn’t keep static methods even though they are defined in externs.

Externs	Source
/** * @fileoverview * @externs */ /** * @interface */ var Test /** * @param {string} test */ Test.staticMethod = function(test) {} /** * @param {string} test */ Test.prototype.api = function(test) {} var module /** @type {!Object} */ module.exports	import './externs' /** * @implements {Test} */ class Example { api(test) { console.log(test) } /** @nocollapse */ static staticMethod(test) { console.error(test) } } module.exports = Example

OUTPUT

'use strict';
class b {
  api(a) {
    console.log(a);
  }
  static a(a) {
    console.error(a);
  }
}
module.exports = b;

java -jar google-closure-compiler-java/compiler.jar --compilation_level \
ADVANCED --language_out ECMASCRIPT_2017 --formatting \
PRETTY_PRINT --js_output_file t/c.js 
--module_resolution NODE --js \
t/index.js t/externs.js

The title says “dropped”, and if there was no nocollapse, the static method would have been removed. The workaround is to write

Workaround	Compiled
/** * @nocollapse * @suppress {checkTypes} */ static 'staticMethod'(test) { console.error(test) }	'use strict'; class b { api(a) { console.log(a); } static ["staticMethod"](a) { console.error(a); } } module.exports = b;

OK the static method is not used, but nor is the instance method – they should both be present, unless I understand wrongly what effect the Test.staticMethod has in externs.

[brad4d]

@zavr-1 to you randomObject defined in externs and the file variable created in your example code seem completely unrelated, but the type information on them is very weak from the compiler’s point of view. Basically, they are seen as simple subclasses of Object which means its safest to assume they are related to each other.

[shicks]

That’s right, good catch - implementing an interface is only about the instance.

@export may not be what you want, either. I’m not sure if there is way to write what you want. Effectively you need to define an extern’d interface for the static part of the class, and then you’d want to declare the class itself as an instance of that interface. But that could break other parts, so it’s not great.

Abstract classes do keep their statics along, but you can’t extend an extern class, since it doesn’t actually exist. Possibly you could fake it with @extends but no extends clause, though that might also cause an error. There’s talk about allowing to “implement” a class (a la TypeScript) but we don’t have anything concrete for that.

I would consider the bug here that we just don’t have a way to write this right now. But I’m also not optimistic about being able to make it possible, since it seems like it will require a pretty significant architectural change.