[bugfix] More careful treatment of export declarations.

corwin-of-amber · corwin-of-amber · commit 790a181784e8 · 2020-08-17T18:08:15.000+03:00
Also, cache results of visiting, towards faster incremental builds.
diff --git a/src/build/bundle.ts b/src/build/bundle.ts
@@ -10,6 +10,7 @@ import acornGlobals from 'acorn-globals';
 import { ModuleRef, SourceFile, PackageDir, TransientCode, NodeModule, ShimModule,
          StubModule, ModuleDependency, FileNotFound } from './modules';
 import { Transpiler } from './transpile';
+import { BuildCache } from './cache';
 import { Report, ReportSilent } from './ui/report';
 
 
@@ -88,6 +89,7 @@ class SearchPath {
 class Environment {
     infra: Library[] = []
     compilers: Transpiler[] = []
+    cache: BuildCache = new BuildCache
     report: Report = new ReportSilent
 }
 
@@ -152,7 +154,7 @@ class AcornCrawl extends InEnvironment {
         while (wl.length > 0) {
             var u = wl.pop().normalize(), key = u.id;
             if (!vs.has(key)) {
-                var r = this.visitModuleRef(u);
+                var r = this.memo(u, u => this.visitModuleRef(u));
                 wl.push(...r.deps.map(d => d.target));
                 vs.set(key, r);
             }
@@ -165,6 +167,10 @@ class AcornCrawl extends InEnvironment {
         return vs.get(key) || this.visitModuleRef(ref);
     }
 
+    memo(m: ModuleRef, op: (m: ModuleRef) => VisitResult) {
+        return this.env.cache.memo(m, 'visit', op);
+    }
+
     visitFile(ref: SourceFile, opts: VisitOptions = {}): VisitResult {
         var fn = ref.filename;
         if      (fn.endsWith('.js'))   return this.visitJSFile(ref, opts);
@@ -220,7 +226,8 @@ class AcornCrawl extends InEnvironment {
 
         m.extractImports();
         var deps = m.imports.map(u => mkdep(u, lookup(u.source.value)))
-            .concat(m.requires.map(u => mkdep(u, lookup(u.arguments[0].value))));
+            .concat(m.requires.map(u => mkdep(u, lookup(u.arguments[0].value))))
+            .concat(m.exportsFrom.map(u => mkdep(u, lookup(u.source.value))));
         return {compiled: m, deps};
     }
 
@@ -496,6 +503,11 @@ class AcornJSModule extends InEnvironment implements CompilationUnit {
         return s;
     }
 
+    get exportsFrom() {
+        return this.exports.filter(u => this.isExportFrom(u)) as
+                AcornTypes.ExportNamedDeclaration[];
+    }
+
     isImport(node: acorn.Node): node is AcornTypes.ImportDeclaration {
         return AcornUtils.is(node, 'ImportDeclaration');
     }
@@ -508,7 +520,17 @@ class AcornJSModule extends InEnvironment implements CompilationUnit {
     }
 
     isExport(node: acorn.Node): node is AcornTypes.ExportDeclaration {
-        return AcornUtils.is(node, 'ExportNamedDeclaration') || AcornUtils.is(node, 'ExportDefaultDeclaration');
+        return AcornUtils.is(node, 'ExportNamedDeclaration') ||
+               AcornUtils.is(node, 'ExportDefaultDeclaration');
+    }
+
+    isExportFrom(node: acorn.Node): node is AcornTypes.ExportNamedDeclaration {
+        return AcornUtils.is(node, 'ExportNamedDeclaration') && !!node.source;
+    }
+
+    _isShorthandProperty(node: AcornTypes.Identifier) {
+        return node.parents.slice(-2).some(p =>
+            AcornUtils.is(p, "Property") && p.shorthand);
     }
 
     process(key: string, deps: ModuleDependency<acorn.Node>[]) {
@@ -520,9 +542,12 @@ class AcornJSModule extends InEnvironment implements CompilationUnit {
             }),
             requires = this.requires.map(req => {
                 var dep = deps.find(d => d.source === req);
-                return dep ? [this.processRequire(req, dep.target)] : [];
+                return dep ? this.processRequire(req, dep.target) : [];
+            }),
+            exports = this.exports.map(exp => {
+                var dep = deps.find(d => d.source === exp);  // for `export .. from`
+                return this.processExport(exp, dep && dep.target);
             }),
-            exports = this.exports.map(exp => [this.processExport(exp)]),
 
             prog = TextSource.interpolate(this.text, 
                 [].concat(...imports, ...requires, ...exports)
@@ -543,39 +568,55 @@ class AcornJSModule extends InEnvironment implements CompilationUnit {
                 isDefault = true;
         }
         else {
-            var locals = [];
             lhs = this._freshVar();
             for (let impspec of imp.specifiers) {
                 assert(impspec.type === 'ImportSpecifier');
                 let local = impspec.local.name, imported = impspec.imported.name;
-                locals.push((local == imported) ? local : `${imported}:${local}`);
-                for (let refnode of this.vars.globals.get(local) || []) {
-                    refs.push([refnode, `${lhs}.${imported}`]);
-                }
+                refs.push(...this.updateReferences(local, `${lhs}.${imported}`));
             }
         }
-        return [[imp, `let ${lhs} = ${this.makeRequire(ref, isDefault)};`]].concat(refs);
+        return [[imp, `let ${lhs} = ${this.makeRequire(ref, isDefault)};`]]
+               .concat(refs);
     }
 
     processRequire(req: RequireInvocation, ref: ModuleRef) {
-        return [req, this.makeRequire(ref)];
+        return [[req, this.makeRequire(ref)]];
     }
 
-    processExport(exp: AcornTypes.ExportDeclaration) {
-        var locals = [], rhs: string, is = AcornUtils.is;
+    processExport(exp: AcornTypes.ExportDeclaration, ref: ModuleRef) {
+        var locals = [], rhs: string, is = AcornUtils.is, d = exp.declaration;
+
         if (is(exp, 'ExportNamedDeclaration')) {
-            for (let expspec of exp.specifiers) {
-                assert(expspec.type === 'ExportSpecifier');
-                let local = expspec.local.name, exported = expspec.exported.name;
-                locals.push((local == exported) ? local : `${local}:${exported}`);
+            if (d) {  // <- `export const` etc.
+                locals = (<any>d).declarations.map(u => u.id.name);  /** @todo typing & test other cases */
+            }
+            else {
+                for (let expspec of exp.specifiers) {
+                    assert(expspec.type === 'ExportSpecifier');
+                    let local = expspec.local.name, exported = expspec.exported.name;
+                    locals.push((local == exported) ? local : `${local}:${exported}`);
+                }
             }
-            rhs = `{${locals}}`;
+
+            rhs = (exp.source && ref)   // <- `export .. from`
+                    ? `${this.makeRequire(ref)}, ${JSON.stringify(locals)}`
+                    : `{${locals}}`;
+
+            if (d)
+                return [[{start: exp.start, end: d.start}, ''],  // <- remove `export` modifier
+                    [{start: exp.end, end:exp.end}, `\nkremlin.export(module, ${rhs});`]];
+            else
+                return [[exp, `kremlin.export(module, ${rhs});`]];
         }
         else if (is(exp, 'ExportDefaultDeclaration')) {
-            rhs = `{default:${this.text.substring(exp.declaration.start, exp.declaration.end)}}`;
+            assert(d);
+            // Careful incision
+            return [[{start: exp.start,
+                      end:   d.start},   'kremlin.export(module, {default:'],
+                    [{start: d.end,
+                      end:   exp.end},   '});']];
         }
         else throw new Error(`invalid export '${exp.type}'`);
-        return [exp, `kremlin.export(module, ${rhs});`];
     }
 
     makeRequire(ref: ModuleRef, isDefault: boolean = false) {
@@ -588,6 +629,16 @@ class AcornJSModule extends InEnvironment implements CompilationUnit {
         }
     }
 
+    updateReferences(name: string, expr: string) {
+        var refs = [];
+        for (let refnode of this.vars.globals.get(name) || []) {
+            var colon = this._isShorthandProperty(refnode);
+            refs.push([refnode, 
+                 `${colon ? name+':' : ''}${expr}`]);
+        }
+        return refs;
+    }
+
     _freshVar(base = "") {
         if (!this.vars) this.extractVars();
         for (let i = 0; ; i++) {
@@ -655,6 +706,7 @@ declare namespace AcornTypes {
 
     class ExportDeclaration extends acorn.Node {
         type: "ExportNamedDeclaration" | "ExportDefaultDeclaration"
+        declaration?: acorn.Node
     }
 
     class ExportNamedDeclaration extends ExportDeclaration {
@@ -665,7 +717,7 @@ declare namespace AcornTypes {
 
     class ExportDefaultDeclaration extends ExportDeclaration {
         type: "ExportDefaultDeclaration"
-        declaration: acorn.Node
+        declaration: acorn.Node   // not optional
     }
 
     class ExportSpecifier extends acorn.Node {
@@ -681,17 +733,23 @@ declare namespace AcornTypes {
 
     class Identifier extends acorn.Node {
         name: string
+        parents: acorn.Node[]  // actually this exists in for all acorn.Nodes :/
+    }
+
+    class Property extends acorn.Node {
+        shorthand: boolean
     }
 
 }
 
 namespace AcornUtils {
     export function is(node: acorn.Node, type: "Program"): node is AcornTypes.Program
     export function is(node: acorn.Node, type: "ImportSpecifier"): node is AcornTypes.ImportSpecifier
-    export function is(node: acorn.Node, type: "CallExpression"): node is AcornTypes.CallExpression
-    export function is(node: acorn.Node, type: "Identifier"): node is AcornTypes.Identifier
     export function is(node: acorn.Node, type: "ExportNamedDeclaration"): node is AcornTypes.ExportNamedDeclaration
     export function is(node: acorn.Node, type: "ExportDefaultDeclaration"): node is AcornTypes.ExportDefaultDeclaration
+    export function is(node: acorn.Node, type: "CallExpression"): node is AcornTypes.CallExpression
+    export function is(node: acorn.Node, type: "Identifier"): node is AcornTypes.Identifier
+    export function is(node: acorn.Node, type: "Property"): node is AcornTypes.Property
     export function is(node: acorn.Node, type: string): boolean
 
     export function is(node: acorn.Node, type: string) { return node.type === type; }
diff --git a/src/build/cache.ts b/src/build/cache.ts
@@ -0,0 +1,61 @@
+const fs = (0||require)('fs') as typeof import('fs');
+
+import { ModuleRef, SourceFile } from './modules';
+import { VisitResult } from './bundle';
+
+
+
+class BuildCache {
+
+    modules: Map<string, BuildCache.Entry>
+
+    constructor() {
+        this.modules = new Map;
+    }
+
+    get(m: ModuleRef): BuildCache.Entry {
+        var stamp = this.stamp(m);
+        if (!stamp) return {stamp: null};  // not cached
+
+        var key = m.id,
+            value = this.modules.get(key);
+
+        if (!value || value.stamp !== stamp)
+            this.modules.set(key, value = {stamp});
+        return value;
+    }
+
+    stamp(m: ModuleRef): BuildCache.Stamp {
+        if (m instanceof SourceFile) {
+            try {
+                var stat = fs.statSync(m.filename);
+                return +stat.mtime;
+            }
+            catch { }
+        }
+    }
+
+    memo<K extends keyof Entry>(m: ModuleRef, field: K,
+                                op: (m: ModuleRef) => Entry[K]): Entry[K] {
+        var e = this.get(m), v = e[field];
+        return v || (e[field] = op(m));
+    }
+}
+
+type Entry = BuildCache.Entry;
+
+
+namespace BuildCache {
+
+    export type Entry = {
+        stamp: Stamp
+        visit?: VisitResult
+    };
+
+    export type Stamp = number;
+
+}
+
+
+
+export { BuildCache }
diff --git a/src/build/include.js b/src/build/include.js
@@ -21,8 +21,12 @@ kremlin = {m: {}, loaded: {},
             Object.assign(c, this.require(k));  // what if c is not an object?
         return c;
     },
-    export(m, d) {
-        m.exports = Object.assign(m.exports || {}, d);
+    export(m, d, names) {
+        m.exports = m.exports || {};
+        if (names)
+            for (let nm of names) m.exports[nm] = d[nm]
+        else
+            m.exports = Object.assign(m.exports, d);
     },
     node_require(nm) {
         var m = require(nm);
