Description
Search Terms
iife namespace nest
Suggestion
Produce a single IIFE for a nested namespace, where applicable.
The point is to reduce onion-like layering in scenarios where it is both trivial and safe to do. There would still be at least 1 level of IIFE wrapping. Every aspect of runtime/semantic/scoping behaviours is preserved as in the current emit.
Example
TypeScript | JavaScript |
---|---|
namespace A.B.C {
export function some() {
return 'A.B.C.some';
}
} |
var A;
(function (A) {
var B;
(function (B) {
var C;
(function (C) {
function some() {
return 'A.B.C.some';
}
C.some = some;
})(C = B.C || (B.C = {}));
})(B = A.B || (A.B = {}));
})(A || (A = {})); |
desired JavaScript | |
var A;
(function (A) {
var B = A.B || (A.B = {});
var C = B.C || (B.C = {});
function some() {
return 'A.B.C.some';
}
C.some = some;
})(A || (A = {})); |
Use Cases
Nested IIFE can affect performance, epecially in older/constrained environments. Of course, in general case they cannot be avoided, as they create lexical scopes and may have code living in all those nesting levels.
But there are several easy-to-detect scenarios where avoiding IIFE infestation is cheap and easy:
namespace A.B.C
with single statement of dot-separated nest chainnamespace A { namespace B {} }
with namespace having a single AST node child of another namespace- may have 2 slightly different cases depends on
export
modifier
- may have 2 slightly different cases depends on
- combination of the above
Note that this feature only affects JS emits, but not parsing neither declaration handling.
Also, this may feel related to #447 Partial modules and output optimization, but the suggestion there is much more broad and heavy to implementation.
Here I do not suggest merging of scopes, just eliminating an easy-to-detect subset of empty scopes that have no code in them.
Non-targeted cases
- This feature explicitly DOES NOT suggest merging consecutive scopes, whether in one file or multiple (that may be a valid thing to do elsewhere).
- This feature explicitly DOES NOT suggest eliding scopes that have code in them (that would be an error, and should be tested against by a valid implementation).
- This feature explicitly DOES NOT intend to elide all possible scopes/layers, only a very few specific easy to check cases.
Checklist
My suggestion meets these guidelines:
- This wouldn't be a breaking change in existing TypeScript/JavaScript code
- This wouldn't change the runtime behavior of existing JavaScript code
- This could be implemented without emitting different JS based on the types of the expressions
- This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
- This feature would agree with the rest of TypeScript's Design Goals.