littlewing 0.9.4 → 0.9.5

package/dist/index.d.ts

@@ -652,16 +652,16 @@ declare class Lexer {
 	private isWhitespace;
 }
 /**
-* Optimize an AST using constant folding and expression simplification.
+* Optimize an AST using constant folding, expression simplification, and dead code elimination.
 *
-* This optimizer performs LOCAL, SAFE optimizations that preserve program semantics:
+* This optimizer performs SAFE optimizations that preserve program semantics:
 * - Constant folding: Evaluates arithmetic with literal operands at compile-time
 * - Function argument pre-evaluation: Simplifies expressions passed to functions
 * - Conditional folding: Evaluates ternary with constant condition
+* - Dead code elimination: Removes unused variable assignments
 *
 * Optimizations that are NOT performed (because they're unsafe with context variables):
 * - Variable propagation: Variables can be overridden by ExecutionContext
-* - Dead code elimination: Cannot determine if variables are "dead" without knowing context
 * - Cross-statement analysis: Each statement may affect external state
 *
 * Time complexity: O(n) where n is the number of AST nodes
@@ -669,7 +669,7 @@ declare class Lexer {
 *
 * Algorithm properties:
 * - Sound: Preserves program semantics exactly
-* - Safe: No assumptions about variable values or liveness
+* - Safe: No assumptions about variable values
 * - Local: Only optimizes within individual expressions
 *
 * @param node - The AST node to optimize

package/dist/index.js

@@ -93,6 +93,139 @@ function visitPartial(node, visitor, defaultHandler) {
   return defaultHandler(node, recurse);
 }
 
+// src/utils.ts
+function evaluateBinaryOperation(operator, left, right) {
+  switch (operator) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      if (right === 0) {
+        throw new Error("Division by zero");
+      }
+      return left / right;
+    case "%":
+      if (right === 0) {
+        throw new Error("Modulo by zero");
+      }
+      return left % right;
+    case "^":
+      return left ** right;
+    case "==":
+      return left === right ? 1 : 0;
+    case "!=":
+      return left !== right ? 1 : 0;
+    case "<":
+      return left < right ? 1 : 0;
+    case ">":
+      return left > right ? 1 : 0;
+    case "<=":
+      return left <= right ? 1 : 0;
+    case ">=":
+      return left >= right ? 1 : 0;
+    case "&&":
+      return left !== 0 && right !== 0 ? 1 : 0;
+    case "||":
+      return left !== 0 || right !== 0 ? 1 : 0;
+    default:
+      throw new Error(`Unknown operator: ${operator}`);
+  }
+}
+function getOperatorPrecedence(operator) {
+  switch (operator) {
+    case "^":
+      return 8;
+    case "*":
+    case "/":
+    case "%":
+      return 7;
+    case "+":
+    case "-":
+      return 6;
+    case "==":
+    case "!=":
+    case "<":
+    case ">":
+    case "<=":
+    case ">=":
+      return 5;
+    case "&&":
+      return 4;
+    case "||":
+      return 3;
+    default:
+      return 0;
+  }
+}
+function collectAllIdentifiers(node) {
+  const identifiers = new Set;
+  visit(node, {
+    Program: (n, recurse) => {
+      for (const stmt of n.statements) {
+        recurse(stmt);
+      }
+    },
+    NumberLiteral: () => {},
+    Identifier: (n) => {
+      identifiers.add(n.name);
+    },
+    BinaryOp: (n, recurse) => {
+      recurse(n.left);
+      recurse(n.right);
+    },
+    UnaryOp: (n, recurse) => {
+      recurse(n.argument);
+    },
+    FunctionCall: (n, recurse) => {
+      for (const arg of n.arguments) {
+        recurse(arg);
+      }
+    },
+    Assignment: (n, recurse) => {
+      recurse(n.value);
+    },
+    ConditionalExpression: (n, recurse) => {
+      recurse(n.condition);
+      recurse(n.consequent);
+      recurse(n.alternate);
+    }
+  });
+  return identifiers;
+}
+function getTokenPrecedence(type) {
+  switch (type) {
+    case "EQUALS" /* EQUALS */:
+      return 1;
+    case "QUESTION" /* QUESTION */:
+      return 2;
+    case "LOGICAL_OR" /* LOGICAL_OR */:
+      return 3;
+    case "LOGICAL_AND" /* LOGICAL_AND */:
+      return 4;
+    case "DOUBLE_EQUALS" /* DOUBLE_EQUALS */:
+    case "NOT_EQUALS" /* NOT_EQUALS */:
+    case "LESS_THAN" /* LESS_THAN */:
+    case "GREATER_THAN" /* GREATER_THAN */:
+    case "LESS_EQUAL" /* LESS_EQUAL */:
+    case "GREATER_EQUAL" /* GREATER_EQUAL */:
+      return 5;
+    case "PLUS" /* PLUS */:
+    case "MINUS" /* MINUS */:
+      return 6;
+    case "STAR" /* STAR */:
+    case "SLASH" /* SLASH */:
+    case "PERCENT" /* PERCENT */:
+      return 7;
+    case "CARET" /* CARET */:
+      return 8;
+    default:
+      return 0;
+  }
+}
+
 // src/analyzer.ts
 function extractInputVariables(ast) {
   const inputVars = new Set;
@@ -107,55 +240,7 @@ function extractInputVariables(ast) {
   return Array.from(inputVars);
 }
 function containsVariableReference(node) {
-  let hasIdentifier = false;
-  visitPartial(node, {
-    Identifier: () => {
-      hasIdentifier = true;
-      return;
-    }
-  }, (n, recurse) => {
-    if (hasIdentifier) {
-      return;
-    }
-    switch (n.type) {
-      case "NumberLiteral":
-        return;
-      case "BinaryOp":
-        recurse(n.left);
-        recurse(n.right);
-        return;
-      case "UnaryOp":
-        recurse(n.argument);
-        return;
-      case "FunctionCall":
-        for (const arg of n.arguments) {
-          recurse(arg);
-          if (hasIdentifier)
-            break;
-        }
-        return;
-      case "ConditionalExpression":
-        recurse(n.condition);
-        if (!hasIdentifier)
-          recurse(n.consequent);
-        if (!hasIdentifier)
-          recurse(n.alternate);
-        return;
-      case "Program":
-        for (const stmt of n.statements) {
-          recurse(stmt);
-          if (hasIdentifier)
-            break;
-        }
-        return;
-      case "Assignment":
-        recurse(n.value);
-        return;
-      default:
-        return;
-    }
-  });
-  return hasIdentifier;
+  return collectAllIdentifiers(node).size > 0;
 }
 // src/ast.ts
 var exports_ast = {};
@@ -288,104 +373,6 @@ function logicalAnd(left, right) {
 function logicalOr(left, right) {
   return binaryOp(left, "||", right);
 }
-// src/utils.ts
-function evaluateBinaryOperation(operator, left, right) {
-  switch (operator) {
-    case "+":
-      return left + right;
-    case "-":
-      return left - right;
-    case "*":
-      return left * right;
-    case "/":
-      if (right === 0) {
-        throw new Error("Division by zero");
-      }
-      return left / right;
-    case "%":
-      if (right === 0) {
-        throw new Error("Modulo by zero");
-      }
-      return left % right;
-    case "^":
-      return left ** right;
-    case "==":
-      return left === right ? 1 : 0;
-    case "!=":
-      return left !== right ? 1 : 0;
-    case "<":
-      return left < right ? 1 : 0;
-    case ">":
-      return left > right ? 1 : 0;
-    case "<=":
-      return left <= right ? 1 : 0;
-    case ">=":
-      return left >= right ? 1 : 0;
-    case "&&":
-      return left !== 0 && right !== 0 ? 1 : 0;
-    case "||":
-      return left !== 0 || right !== 0 ? 1 : 0;
-    default:
-      throw new Error(`Unknown operator: ${operator}`);
-  }
-}
-function getOperatorPrecedence(operator) {
-  switch (operator) {
-    case "^":
-      return 8;
-    case "*":
-    case "/":
-    case "%":
-      return 7;
-    case "+":
-    case "-":
-      return 6;
-    case "==":
-    case "!=":
-    case "<":
-    case ">":
-    case "<=":
-    case ">=":
-      return 5;
-    case "&&":
-      return 4;
-    case "||":
-      return 3;
-    default:
-      return 0;
-  }
-}
-function getTokenPrecedence(type) {
-  switch (type) {
-    case "EQUALS" /* EQUALS */:
-      return 1;
-    case "QUESTION" /* QUESTION */:
-      return 2;
-    case "LOGICAL_OR" /* LOGICAL_OR */:
-      return 3;
-    case "LOGICAL_AND" /* LOGICAL_AND */:
-      return 4;
-    case "DOUBLE_EQUALS" /* DOUBLE_EQUALS */:
-    case "NOT_EQUALS" /* NOT_EQUALS */:
-    case "LESS_THAN" /* LESS_THAN */:
-    case "GREATER_THAN" /* GREATER_THAN */:
-    case "LESS_EQUAL" /* LESS_EQUAL */:
-    case "GREATER_EQUAL" /* GREATER_EQUAL */:
-      return 5;
-    case "PLUS" /* PLUS */:
-    case "MINUS" /* MINUS */:
-      return 6;
-    case "STAR" /* STAR */:
-    case "SLASH" /* SLASH */:
-    case "PERCENT" /* PERCENT */:
-      return 7;
-    case "CARET" /* CARET */:
-      return 8;
-    default:
-      return 0;
-  }
-}
-
 // src/codegen.ts
 class CodeGenerator {
   generate(node) {
@@ -1228,8 +1215,42 @@ function humanize(node, options) {
   return humanizer.humanize(node);
 }
 // src/optimizer.ts
+function eliminateDeadCode(program2) {
+  const statements = program2.statements;
+  const liveVars = new Set;
+  const keptStatements = [];
+  for (let i = statements.length - 1;i >= 0; i--) {
+    const stmt = statements[i];
+    if (!stmt)
+      continue;
+    if (i === statements.length - 1) {
+      keptStatements.push(stmt);
+      const identifiers = collectAllIdentifiers(stmt);
+      for (const id of identifiers) {
+        liveVars.add(id);
+      }
+      continue;
+    }
+    if (stmt.type === "Assignment") {
+      if (liveVars.has(stmt.name)) {
+        keptStatements.push(stmt);
+        const identifiers = collectAllIdentifiers(stmt.value);
+        for (const id of identifiers) {
+          liveVars.add(id);
+        }
+      }
+    } else {
+      keptStatements.push(stmt);
+      const identifiers = collectAllIdentifiers(stmt);
+      for (const id of identifiers) {
+        liveVars.add(id);
+      }
+    }
+  }
+  return program(keptStatements.reverse());
+}
 function optimize(node) {
-  return visit(node, {
+  const folded = visit(node, {
     NumberLiteral: (n) => n,
     Identifier: (n) => n,
     BinaryOp: (n, recurse) => {
@@ -1274,6 +1295,10 @@ function optimize(node) {
       return program(optimizedStatements);
     }
   });
+  if (isProgram(folded) && folded.statements.length > 0) {
+    return eliminateDeadCode(folded);
+  }
+  return folded;
 }
 export {
   visitPartial,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "0.9.4",
+	"version": "0.9.5",
 	"description": "A minimal, high-performance arithmetic expression language with lexer, parser, and executor. Optimized for browsers with zero dependencies and type-safe execution.",
 	"keywords": [
 		"arithmetic",