stone-lang 0.1.0

package/frontend/analysis/treeShaker.js

@@ -0,0 +1,265 @@
+/**
+ * Stone Module Tree Shaker
+ *
+ * Analyzes imports to determine which exports are actually used from each module,
+ * enabling optimization of module loading and reducing memory usage.
+ *
+ * Features:
+ * - Analyzes import statements to track which exports are used
+ * - Filters module exports to only include used names
+ * - Detects unused imports for warnings
+ * - Supports selective imports, namespace imports, and re-exports
+ *
+ * Usage:
+ *   const analyzer = new ImportAnalyzer();
+ *   const usedExports = analyzer.analyze(ast);
+ *   // usedExports is Map<modulePath, Set<exportName>>
+ *
+ *   const shaker = new TreeShaker();
+ *   const filteredExports = shaker.filterExports(moduleExports, usedExports.get(modulePath));
+ */
+
+/**
+ * Analyzes an AST to determine which exports are used from each imported module
+ */
+export class ImportAnalyzer {
+  constructor() {
+    // Map from module path to Set of imported names
+    this.usedExports = new Map();
+    // Map from local name to { modulePath, importedName }
+    this.importedBindings = new Map();
+    // Set of local names that are actually referenced in code
+    this.referencedNames = new Set();
+    // Track namespace imports: localName -> modulePath
+    this.namespaceImports = new Map();
+  }
+
+  /**
+   * Analyze an AST and return a map of used exports per module
+   * @param {Object} ast - The parsed AST
+   * @returns {Map<string, Set<string>>} Map from module path to set of used export names
+   */
+  analyze(ast) {
+    this.usedExports.clear();
+    this.importedBindings.clear();
+    this.referencedNames.clear();
+    this.namespaceImports.clear();
+
+    // First pass: collect all imports
+    this._collectImports(ast);
+
+    // Second pass: collect all identifier references
+    this._collectReferences(ast);
+
+    // Third pass: determine which imports are actually used
+    return this._computeUsedExports();
+  }
+
+  /**
+   * Collect all import statements from the AST
+   */
+  _collectImports(ast) {
+    if (!ast || !ast.imports) return;
+
+    for (const importNode of ast.imports) {
+      if (importNode.type === 'ImportStatement') {
+        const modulePath = importNode.modulePath;
+
+        if (!this.usedExports.has(modulePath)) {
+          this.usedExports.set(modulePath, new Set());
+        }
+
+        for (const spec of importNode.specifiers) {
+          const importedName = spec.importedName || spec.localName;
+          const localName = spec.localName;
+
+          // Track the binding
+          this.importedBindings.set(localName, {
+            modulePath,
+            importedName,
+          });
+        }
+      } else if (importNode.type === 'NamespaceImportStatement') {
+        const modulePath = importNode.modulePath;
+        const localName = importNode.alias || this._getModuleLastSegment(modulePath);
+
+        // Namespace imports use all exports (marked with '*')
+        if (!this.usedExports.has(modulePath)) {
+          this.usedExports.set(modulePath, new Set());
+        }
+        this.usedExports.get(modulePath).add('*');
+        this.namespaceImports.set(localName, modulePath);
+      }
+    }
+  }
+
+  /**
+   * Collect all identifier references in the AST
+   */
+  _collectReferences(ast) {
+    this._walkAST(ast, (node) => {
+      // Identifier nodes (variable references like `x` in `y = x + 1`)
+      if (node.type === 'Identifier') {
+        this.referencedNames.add(node.name);
+      }
+
+      // FunctionCall nodes have funcName as a string (not an Identifier)
+      if (node.type === 'FunctionCall' && node.funcName) {
+        this.referencedNames.add(node.funcName);
+      }
+
+      // Handle member access on namespace imports: ns.foo
+      if (node.type === 'MemberAccess' && node.object?.type === 'Identifier') {
+        const objName = node.object.name;
+        if (this.namespaceImports.has(objName) && node.property?.name) {
+          // Track the specific property accessed
+          const modulePath = this.namespaceImports.get(objName);
+          if (this.usedExports.has(modulePath)) {
+            this.usedExports.get(modulePath).add(node.property.name);
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Compute which exports are actually used based on references
+   */
+  _computeUsedExports() {
+    // For each imported binding that's referenced, mark its export as used
+    for (const [localName, bindingInfo] of this.importedBindings) {
+      if (this.referencedNames.has(localName)) {
+        const { modulePath, importedName } = bindingInfo;
+        if (this.usedExports.has(modulePath)) {
+          this.usedExports.get(modulePath).add(importedName);
+        }
+      }
+    }
+
+    return this.usedExports;
+  }
+
+  /**
+   * Get unused imports (imports that are never referenced)
+   * @returns {Array<{localName, modulePath, importedName}>}
+   */
+  getUnusedImports() {
+    const unused = [];
+    for (const [localName, bindingInfo] of this.importedBindings) {
+      if (!this.referencedNames.has(localName)) {
+        unused.push({
+          localName,
+          modulePath: bindingInfo.modulePath,
+          importedName: bindingInfo.importedName,
+        });
+      }
+    }
+    return unused;
+  }
+
+  /**
+   * Walk the AST and call callback for each node
+   */
+  _walkAST(node, callback) {
+    if (!node || typeof node !== 'object') return;
+
+    callback(node);
+
+    // Skip certain node types that don't contain code references
+    if (node.type === 'ImportStatement' || node.type === 'NamespaceImportStatement') {
+      return;
+    }
+
+    // Recursively walk all properties
+    for (const key of Object.keys(node)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          this._walkAST(item, callback);
+        }
+      } else if (value && typeof value === 'object' && value.type) {
+        this._walkAST(value, callback);
+      }
+    }
+  }
+
+  /**
+   * Get the last segment of a module path
+   */
+  _getModuleLastSegment(modulePath) {
+    const segments = modulePath.split('/');
+    return segments[segments.length - 1];
+  }
+}
+
+/**
+ * Filters module exports based on what's actually used
+ */
+export class TreeShaker {
+  /**
+   * Filter a module's exports to only include used names
+   * @param {Object} moduleExports - The full exports object from a module
+   * @param {Set<string>} usedNames - Set of export names that are actually used
+   * @returns {Object} Filtered exports object
+   */
+  filterExports(moduleExports, usedNames) {
+    if (!moduleExports || !usedNames) {
+      return moduleExports;
+    }
+
+    // If '*' is in usedNames, return all exports (namespace import)
+    if (usedNames.has('*')) {
+      return moduleExports;
+    }
+
+    // Filter to only include used exports
+    const filtered = {};
+    for (const name of usedNames) {
+      if (name in moduleExports) {
+        filtered[name] = moduleExports[name];
+      }
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Analyze an AST and return tree-shaking metadata
+   * @param {Object} ast - The parsed AST
+   * @returns {Object} Tree-shaking metadata
+   */
+  analyzeAndShake(ast) {
+    const analyzer = new ImportAnalyzer();
+    const usedExports = analyzer.analyze(ast);
+    const unusedImports = analyzer.getUnusedImports();
+
+    return {
+      usedExports,
+      unusedImports,
+      hasUnusedImports: unusedImports.length > 0,
+    };
+  }
+}
+
+/**
+ * Create a tree shaker with import analysis
+ * @param {Object} ast - The parsed AST
+ * @returns {Object} Object with { usedExports, filterExports, unusedImports }
+ */
+export function createTreeShaker(ast) {
+  const analyzer = new ImportAnalyzer();
+  const usedExports = analyzer.analyze(ast);
+  const unusedImports = analyzer.getUnusedImports();
+  const shaker = new TreeShaker();
+
+  return {
+    usedExports,
+    unusedImports,
+    filterExports: (moduleExports, modulePath) => {
+      const used = usedExports.get(modulePath);
+      return shaker.filterExports(moduleExports, used);
+    },
+  };
+}
+
+export default TreeShaker;

package/frontend/index.js

@@ -0,0 +1,20 @@
+/**
+ * Stone Frontend - Barrel exports
+ *
+ * Re-exports all frontend modules: parsing, types, type-checker, analysis, utils
+ */
+
+// Parsing
+export * from './parsing/index.js';
+
+// Types
+export * from './types/index.js';
+
+// Type Checker
+export * from './type-checker/index.js';
+
+// Analysis
+export * from './analysis/index.js';
+
+// Utils
+export * from './utils/index.js';