starting the big function

3 files changed, 576 insertions, 83 deletions

diff --git a/src/js_ast.zig b/src/js_ast.zig
index 289131bf3..7e81b77b5 100644
--- a/src/js_ast.zig
+++ b/src/js_ast.zig
@@ -80,12 +80,18 @@ pub const ImportItemStatus = packed enum {
     missing,
 };
 
+pub const AssignTarget = enum {
+    none,
+    replace, // "a = b"
+    update, // "a += b"
+};
+
 pub const LocRef = struct { loc: logger.Loc, ref: ?Ref };
 
 pub const Flags = struct {
 
-    // Instead of 4 bytes for booleans, we can store it in 4 bits
-    // It will still round up to 1 byte. But that's 3 bytes less!
+    // Instead of 5 bytes for booleans, we can store it in 5 bits
+    // It will still round up to 1 byte. But that's 4 bytes less!
     pub const Property = packed struct {
         is_computed: bool = false,
         is_method: bool = false,
@@ -749,7 +755,7 @@ pub const E = struct {
     };
 
     pub const Object = struct {
-        properties: []G.Property,
+        properties: []G.Property = &([_]G.Property{}),
         comma_after_spread: ?logger.Loc = null,
         is_single_line: bool = false,
         is_parenthesized: bool = false,
@@ -1153,6 +1159,23 @@ pub const Expr = struct {
 
     pub const EFlags = enum { none, ts_decorator };
 
+    pub fn isAnonymousNamed(e: *Expr) bool {
+        switch (e.data) {
+            .e_arrow => {
+                return true;
+            },
+            .e_function => |func| {
+                return func.func.name == null;
+            },
+            .e_class => |class| {
+                return class.class_name == null;
+            },
+            else => {
+                return false;
+            },
+        }
+    }
+
     pub fn init(exp: anytype, loc: logger.Loc) Expr {
         switch (@TypeOf(exp)) {
             *E.Array => {
@@ -2132,7 +2155,7 @@ pub const S = struct {
 
     pub const Comment = struct { text: string };
 
-    pub const Directive = struct { value: JavascriptString, legacy_octal_loc: logger.Loc };
+    pub const Directive = struct { value: JavascriptString, legacy_octal_loc: ?logger.Loc = null };
 
     pub const ExportClause = struct { items: []ClauseItem, is_single_line: bool = false };
 
@@ -2668,8 +2691,6 @@ pub const AstData = struct {
 // splitting.
 pub const Part = struct {
     stmts: []Stmt,
-    expr: []Expr,
-    bindings: []Binding,
     scopes: []*Scope,
 
     // Each is an index into the file-level import record list
@@ -2701,30 +2722,6 @@ pub const Part = struct {
     // This is true if this file has been marked as live by the tree shaking
     // algorithm.
     is_live: bool = false,
-
-    pub fn stmtAt(self: *Part, index: StmtNodeIndex) ?Stmt {
-        if (std.builtin.mode == std.builtin.Mode.ReleaseFast) {
-            return self.stmts[@intCast(usize, index)];
-        } else {
-            if (self.stmts.len > index) {
-                return self.stmts[@intCast(usize, index)];
-            }
-
-            return null;
-        }
-    }
-
-    pub fn exprAt(self: *Part, index: ExprNodeIndex) ?Expr {
-        if (std.builtin.mode == std.builtin.Mode.ReleaseFast) {
-            return self.expr[@intCast(usize, index)];
-        } else {
-            if (self.expr.len > index) {
-                return self.expr[@intCast(usize, index)];
-            }
-
-            return null;
-        }
-    }
 };
 
 pub const StmtOrExpr = union(enum) {
@@ -2816,7 +2813,12 @@ pub const Scope = struct {
 
     pub fn initPtr(allocator: *std.mem.Allocator) !*Scope {
         var scope = try allocator.create(Scope);
-        scope.members = @TypeOf(scope.members).init(allocator);
+        scope.* = Scope{
+            .members = @TypeOf(scope.members).init(allocator),
+            .children = @TypeOf(scope.children).init(allocator),
+            .generated = @TypeOf(scope.generated).init(allocator),
+            .parent = null,
+        };
         return scope;
     }
 };
diff --git a/src/js_parser.zig b/src/js_parser.zig
index a9775dcfb..67a2c4d66 100644
--- a/src/js_parser.zig
+++ b/src/js_parser.zig
@@ -41,6 +41,74 @@ const ExprOrLetStmt = struct {
     decls: []G.Decl = &([_]G.Decl{}),
 };
 
+const ExprIn = struct {
+    // This tells us if there are optional chain expressions (EDot, EIndex, or
+    // ECall) that are chained on to this expression. Because of the way the AST
+    // works, chaining expressions on to this expression means they are our
+    // parent expressions.
+    //
+    // Some examples:
+    //
+    //   a?.b.c  // EDot
+    //   a?.b[c] // EIndex
+    //   a?.b()  // ECall
+    //
+    // Note that this is false if our parent is a node with a OptionalChain
+    // value of OptionalChainStart. That means it's the start of a new chain, so
+    // it's not considered part of this one.
+    //
+    // Some examples:
+    //
+    //   a?.b?.c   // EDot
+    //   a?.b?.[c] // EIndex
+    //   a?.b?.()  // ECall
+    //
+    // Also note that this is false if our parent is a node with a OptionalChain
+    // value of OptionalChainNone. That means it's outside parentheses, which
+    // means it's no longer part of the chain.
+    //
+    // Some examples:
+    //
+    //   (a?.b).c  // EDot
+    //   (a?.b)[c] // EIndex
+    //   (a?.b)()  // ECall
+    //
+    has_chain_parent: bool = false,
+
+    // If our parent is an ECall node with an OptionalChain value of
+    // OptionalChainStart, then we will need to store the value for the "this" of
+    // that call somewhere if the current expression is an optional chain that
+    // ends in a property access. That's because the value for "this" will be
+    // used twice: once for the inner optional chain and once for the outer
+    // optional chain.
+    //
+    // Example:
+    //
+    //   // Original
+    //   a?.b?.();
+    //
+    //   // Lowered
+    //   var _a;
+    //   (_a = a == null ? void 0 : a.b) == null ? void 0 : _a.call(a);
+    //
+    // In the example above we need to store "a" as the value for "this" so we
+    // can substitute it back in when we call "_a" if "_a" is indeed present.
+    // See also "thisArgFunc" and "thisArgWrapFunc" in "exprOut".
+    store_this_arg_for_parent_optional_chain: bool = false,
+
+    // Certain substitutions of identifiers are disallowed for assignment targets.
+    // For example, we shouldn't transform "undefined = 1" into "void 0 = 1". This
+    // isn't something real-world code would do but it matters for conformance
+    // tests.
+    assign_target: js_ast.AssignTarget = js_ast.AssignTarget.none,
+};
+
+const ExprOut = struct {
+    // True if the child node is an optional chain node (EDot, EIndex, or ECall
+    // with an IsOptionalChain value of true)
+    child_contains_optional_chain: bool = false,
+};
+
 const Tup = std.meta.Tuple;
 
 // This function exists to tie all of these checks together in one place
@@ -48,6 +116,17 @@ fn isEvalOrArguments(name: string) bool {
     return strings.eql(name, "eval") or strings.eql(name, "arguments");
 }
 
+const PrependTempRefsOpts = struct {
+    fn_body_loc: ?logger.Loc = null,
+    kind: StmtsKind = StmtsKind.none,
+};
+
+pub const StmtsKind = enum {
+    none,
+    loop_body,
+    fn_body,
+};
+
 fn notimpl() noreturn {
     std.debug.panic("Not implemented yet!!", .{});
 }
@@ -63,8 +142,8 @@ fn fail() noreturn {
 const ExprBindingTuple = struct { expr: ?ExprNodeIndex = null, binding: ?Binding = null, override_expr: ?ExprNodeIndex = null };
 
 const TempRef = struct {
-    ref: js_ast.Ref,
-    value: *js_ast.Expr,
+    ref: Ref,
+    value: ?Expr = null,
 };
 
 const ImportNamespaceCallOrConstruct = struct {
@@ -173,18 +252,18 @@ const FnOnlyDataVisit = struct {
     // This is a reference to the magic "arguments" variable that exists inside
     // functions in JavaScript. It will be non-nil inside functions and nil
     // otherwise.
-    arguments_ref: *js_ast.Ref,
+    arguments_ref: ?js_ast.Ref = null,
 
     // Arrow functions don't capture the value of "this" and "arguments". Instead,
     // the values are inherited from the surrounding context. If arrow functions
     // are turned into regular functions due to lowering, we will need to generate
     // local variables to capture these values so they are preserved correctly.
-    this_capture_ref: *js_ast.Ref,
-    arguments_capture_ref: *js_ast.Ref,
+    this_capture_ref: ?js_ast.Ref = null,
+    arguments_capture_ref: ?js_ast.Ref = null,
 
     // Inside a static class property initializer, "this" expressions should be
     // replaced with the class name.
-    this_class_static_ref: *js_ast.Ref,
+    this_class_static_ref: ?js_ast.Ref = null,
 
     // If we're inside an async arrow function and async functions are not
     // supported, then we will have to convert that arrow function to a generator
@@ -298,6 +377,35 @@ pub const Parser = struct {
             var opts = ParseStatementOptions{ .is_module_scope = true };
             const stmts = try p.parseStmtsUpTo(js_lexer.T.t_end_of_file, &opts);
             try p.prepareForVisitPass();
+
+            // ESM is always strict mode. I don't think we need this.
+            // // Strip off a leading "use strict" directive when not bundling
+            // var directive = "";
+
+            // Insert a variable for "import.meta" at the top of the file if it was used.
+            // We don't need to worry about "use strict" directives because this only
+            // happens when bundling, in which case we are flatting the module scopes of
+            // all modules together anyway so such directives are meaningless.
+            if (!p.import_meta_ref.isNull()) {
+                // heap so it lives beyond this function call
+                var decls = try p.allocator.alloc(G.Decl, 1);
+                decls[0] = Decl{ .binding = p.b(B.Identifier{
+                    .ref = p.import_meta_ref,
+                }, logger.Loc.Empty), .value = p.e(E.Object{}, logger.Loc.Empty) };
+                var importMetaStatement = p.s(S.Local{
+                    .kind = .k_const,
+                    .decls = decls,
+                }, logger.Loc.Empty);
+            }
+
+            var parts = try List(js_ast.Part).initCapacity(p.allocator, 1);
+            try p.appendPart(parts, stmts);
+
+            // Pop the module scope to apply the "ContainsDirectEval" rules
+            p.popScope();
+
+            result = p.toAST(parts);
+            result.source_map_comment = p.lexer.source_mapping_url;
         }
 
         return result;
@@ -325,6 +433,11 @@ pub const Parser = struct {
     }
 };
 
+const FindSymbolResult = struct {
+    ref: Ref,
+    declare_loc: ?logger.Loc = null,
+    is_inside_with_scope: bool = false,
+};
 const ExportClauseResult = struct { clauses: []js_ast.ClauseItem = &([_]js_ast.ClauseItem{}), is_single_line: bool = false };
 
 const DeferredTsDecorators = struct {
@@ -373,7 +486,7 @@ const P = struct {
     allocated_names: List(string),
     latest_arrow_arg_loc: logger.Loc = logger.Loc.Empty,
     forbid_suffix_after_as_loc: logger.Loc = logger.Loc.Empty,
-    current_scope: ?*js_ast.Scope = null,
+    current_scope: *js_ast.Scope = null,
     scopes_for_current_part: List(*js_ast.Scope),
     symbols: List(js_ast.Symbol),
     ts_use_counts: List(u32),
@@ -604,19 +717,72 @@ const P = struct {
         parser.relocated_top_level_vars.deinit();
     }
 
-    pub fn findSymbol(self: *P, loc: logger.Loc, name: string) ?js_ast.Symbol {
-        return null;
+    pub fn findSymbol(p: *P, loc: logger.Loc, name: string) !FindSymbolResult {
+        var ref: Ref = undefined;
+        var declare_loc: logger.Loc = undefined;
+        var is_inside_with_scope = false;
+        var did_forbid_argumen = false;
+        var scope = p.current_scope;
+
+        while (true) {
+
+            // Track if we're inside a "with" statement body
+            if (scope.kind == .with) {
+                is_inside_with_scope = true;
+            }
+
+            // Forbid referencing "arguments" inside class bodies
+            if (scope.forbid_arguments and strings.eql(name, "arguments") and !did_forbid_argumen) {
+                const r = js_lexer.rangeOfIdentifier(&p.source, loc);
+                p.log.addRangeErrorFmt(p.source, r, p.allocator, "Cannot access \"{s}\" here", .{name}) catch unreachable;
+                did_forbid_argumen = true;
+            }
+
+            // Is the symbol a member of this scope?
+            if (scope.members.get(name)) |member| {
+                ref = member.ref;
+                declare_loc = member.loc;
+                break;
+            }
+
+            if (scope.parent) |parent| {
+                scope = parent;
+            } else {
+                // Allocate an "unbound" symbol
+                p.checkForNonBMPCodePoint(loc, name);
+                ref = try p.newSymbol(.unbound, name);
+                declare_loc = loc;
+                try p.module_scope.members.put(name, js_ast.Scope.Member{ .ref = ref, .loc = logger.Loc.Empty });
+                break;
+            }
+        }
+
+        // If we had to pass through a "with" statement body to get to the symbol
+        // declaration, then this reference could potentially also refer to a
+        // property on the target object of the "with" statement. We must not rename
+        // it or we risk changing the behavior of the code.
+        if (is_inside_with_scope) {
+            p.symbols.items[ref.inner_index].must_not_be_renamed = true;
+        }
+
+        // Track how many times we've referenced this symbol
+        p.recordUsage(&ref);
+        return FindSymbolResult{
+            .ref = ref,
+            .declare_loc = declare_loc,
+            .is_inside_with_scope = is_inside_with_scope,
+        };
     }
 
-    pub fn recordUsage(self: *P, ref: *js_ast.Ref) void {
+    pub fn recordUsage(p: *P, ref: *js_ast.Ref) void {
         // The use count stored in the symbol is used for generating symbol names
         // during minification. These counts shouldn't include references inside dead
         // code regions since those will be culled.
         if (!p.is_control_flow_dead) {
-            p.symbols[ref.inner_index].use_count_estimate += 1;
-            var use = p.symbol_uses[ref];
+            p.symbols.items[ref.inner_index].use_count_estimate += 1;
+            var use = p.symbol_uses.get(ref.*) orelse unreachable;
             use.count_estimate += 1;
-            p.symbol_uses.put(ref, use);
+            p.symbol_uses.put(ref.*, use) catch unreachable;
         }
 
         // The correctness of TypeScript-to-JavaScript conversion relies on accurate
@@ -747,7 +913,7 @@ const P = struct {
     pub fn prepareForVisitPass(p: *P) !void {
         try p.pushScopeForVisitPass(js_ast.Scope.Kind.entry, locModuleScope);
         p.fn_or_arrow_data_visit.is_outside_fn_or_arrow = true;
-        p.module_scope = p.current_scope orelse unreachable;
+        p.module_scope = p.current_scope;
         p.has_es_module_syntax = p.es6_import_keyword.len > 0 or p.es6_export_keyword.len > 0 or p.top_level_await_keyword.len > 0;
 
         // ECMAScript modules are always interpreted as strict mode. This has to be
@@ -801,7 +967,7 @@ const P = struct {
     }
 
     pub fn pushScopeForParsePass(p: *P, kind: js_ast.Scope.Kind, loc: logger.Loc) !usize {
-        var parent = p.current_scope orelse unreachable;
+        var parent = p.current_scope;
         var scope = try js_ast.Scope.initPtr(p.allocator);
         scope.kind = kind;
         scope.parent = parent;
@@ -1059,7 +1225,7 @@ const P = struct {
 
     pub fn popAndDiscardScope(p: *P, scope_index: usize) void {
         // Move up to the parent scope
-        var to_discard = p.current_scope orelse unreachable;
+        var to_discard = p.current_scope;
         var parent = to_discard.parent orelse unreachable;
 
         p.current_scope = parent;
@@ -1161,7 +1327,7 @@ const P = struct {
 
         const name = js_ast.LocRef{ .loc = loc, .ref = try p.newSymbol(Symbol.Kind.other, identifier) };
 
-        var scope = p.current_scope orelse unreachable;
+        var scope = p.current_scope;
 
         try scope.generated.append(name.ref orelse unreachable);
 
@@ -2152,7 +2318,7 @@ const P = struct {
                     var path_name = fs.PathName.init(strings.append(p.allocator, "import_", path.text) catch unreachable);
                     const name = try path_name.nonUniqueNameString(p.allocator);
                     stmt.namespace_ref = try p.newSymbol(.other, name);
-                    var scope: *Scope = p.current_scope orelse unreachable;
+                    var scope: *Scope = p.current_scope;
                     try scope.generated.append(stmt.namespace_ref);
                 }
 
@@ -2417,7 +2583,7 @@ const P = struct {
 
     pub fn discardScopesUpTo(p: *P, scope_index: usize) void {
         // Remove any direct children from their parent
-        var scope = p.current_scope orelse unreachable;
+        var scope = p.current_scope;
         var children = scope.children;
         for (p.scopes_in_order.items[scope_index..]) |child| {
             if (child.scope.parent == p.current_scope) {
@@ -3017,9 +3183,80 @@ const P = struct {
                 break :run;
             }
 
-            const stmt = p.parseStmt(opts) catch break :run;
+            var stmt = p.parseStmt(opts) catch break :run;
+
+            // Skip TypeScript types entirely
+            if (p.options.ts) {
+                switch (stmt.data) {
+                    .s_type_script => {
+                        continue;
+                    },
+                    else => {},
+                }
+            }
+
+            // Parse one or more directives at the beginning
+            if (isDirectivePrologue) {
+                isDirectivePrologue = false;
+                switch (stmt.data) {
+                    .s_expr => |expr| {
+                        switch (expr.value.data) {
+                            .e_string => |str| {
+                                if (!str.prefer_template) {
+                                    stmt.data = Stmt.Data{
+                                        .s_directive = p.m(S.Directive{
+                                            .value = str.value,
+                                            // .legacy_octal_loc = str.legacy_octal_loc,
+                                        }),
+                                    };
+                                    isDirectivePrologue = true;
+
+                                    if (strings.eqlUtf16("use strict", str.value)) {
+                                        // Track "use strict" directives
+                                        p.current_scope.strict_mode = .explicit_strict_mode;
+                                    } else if (strings.eqlUtf16("use asm", str.value)) {
+                                        stmt.data = Stmt.Data{ .s_empty = p.m(S.Empty{}) };
+                                    }
+                                }
+                            },
+                            else => {},
+                        }
+                    },
+                    else => {},
+                }
+            }
 
             try stmts.append(stmt);
+
+            // Warn about ASI and return statements. Here's an example of code with
+            // this problem: https://github.com/rollup/rollup/issues/3729
+            if (!p.options.suppress_warnings_about_weird_code) {
+                var needsCheck = true;
+                switch (stmt.data) {
+                    .s_return => |ret| {
+                        if (ret.value == null and !p.latest_return_had_semicolon) {
+                            returnWithoutSemicolonStart = stmt.loc.start;
+                            needsCheck = false;
+                        }
+                    },
+                    else => {},
+                }
+
+                if (needsCheck and returnWithoutSemicolonStart != -1) {
+                    switch (stmt.data) {
+                        .s_expr => |exp| {
+                            try p.log.addWarning(
+                                p.source,
+                                logger.Loc{ .start = returnWithoutSemicolonStart + 6 },
+                                "The following expression is not returned because of an automatically-inserted semicolon",
+                            );
+                        },
+                        else => {},
+                    }
+
+                    returnWithoutSemicolonStart = -1;
+                }
+            }
         }
 
         return stmts.toOwnedSlice();
@@ -3059,40 +3296,39 @@ const P = struct {
             // },
         }
 
-        if (p.current_scope) |scope| {
-            if (p.isStrictMode()) {
-                var why: string = "";
-                var notes: []logger.Data = undefined;
-                var where: logger.Range = undefined;
-                switch (scope.strict_mode) {
-                    .implicit_strict_mode_import => {
-                        where = p.es6_import_keyword;
-                    },
-                    .implicit_strict_mode_export => {
-                        where = p.es6_export_keyword;
-                    },
-                    .implicit_strict_mode_top_level_await => {
-                        where = p.top_level_await_keyword;
-                    },
-                    .implicit_strict_mode_class => {
-                        why = "All code inside a class is implicitly in strict mode";
-                        where = p.enclosing_class_keyword;
-                    },
-                    else => {},
-                }
-                if (why.len == 0) {
-                    why = try std.fmt.allocPrint(p.allocator, "This file is implicitly in strict mode because of the \"{s}\" keyword here", .{p.source.textForRange(where)});
-                }
-
-                try p.log.addRangeErrorWithNotes(p.source, r, try std.fmt.allocPrint(p.allocator, "{s} cannot be used in strict mode", .{text}), &([_]logger.Data{logger.rangeData(p.source, where, why)}));
-            } else if (!can_be_transformed and p.isStrictModeOutputFormat()) {
-                try p.log.addRangeError(p.source, r, try std.fmt.allocPrint(p.allocator, "{s} cannot be used with \"esm\" due to strict mode", .{text}));
+        var scope = p.current_scope;
+        if (p.isStrictMode()) {
+            var why: string = "";
+            var notes: []logger.Data = undefined;
+            var where: logger.Range = undefined;
+            switch (scope.strict_mode) {
+                .implicit_strict_mode_import => {
+                    where = p.es6_import_keyword;
+                },
+                .implicit_strict_mode_export => {
+                    where = p.es6_export_keyword;
+                },
+                .implicit_strict_mode_top_level_await => {
+                    where = p.top_level_await_keyword;
+                },
+                .implicit_strict_mode_class => {
+                    why = "All code inside a class is implicitly in strict mode";
+                    where = p.enclosing_class_keyword;
+                },
+                else => {},
+            }
+            if (why.len == 0) {
+                why = try std.fmt.allocPrint(p.allocator, "This file is implicitly in strict mode because of the \"{s}\" keyword here", .{p.source.textForRange(where)});
             }
+
+            try p.log.addRangeErrorWithNotes(p.source, r, try std.fmt.allocPrint(p.allocator, "{s} cannot be used in strict mode", .{text}), &([_]logger.Data{logger.rangeData(p.source, where, why)}));
+        } else if (!can_be_transformed and p.isStrictModeOutputFormat()) {
+            try p.log.addRangeError(p.source, r, try std.fmt.allocPrint(p.allocator, "{s} cannot be used with \"esm\" due to strict mode", .{text}));
         }
     }
 
     pub fn isStrictMode(p: *P) bool {
-        return p.current_scope.?.strict_mode != .sloppy_mode;
+        return p.current_scope.strict_mode != .sloppy_mode;
     }
 
     pub fn isStrictModeOutputFormat(p: *P) bool {
@@ -3110,7 +3346,7 @@ const P = struct {
         // Allocate a new symbol
         var ref = try p.newSymbol(kind, name);
 
-        const scope = p.current_scope orelse unreachable;
+        const scope = p.current_scope;
         if (scope.members.get(name)) |existing| {
             var symbol: Symbol = p.symbols.items[@intCast(usize, existing.ref.inner_index)];
 
@@ -3505,7 +3741,7 @@ const P = struct {
     }
 
     pub fn popScope(p: *P) void {
-        const current_scope = p.current_scope orelse unreachable;
+        const current_scope = p.current_scope;
         // We cannot rename anything inside a scope containing a direct eval() call
         if (current_scope.contains_direct_eval) {
             var iter = current_scope.members.iterator();
@@ -3560,7 +3796,7 @@ const P = struct {
             }
         }
 
-        p.current_scope = current_scope.parent;
+        p.current_scope = current_scope.parent orelse std.debug.panic("Internal error: attempted to call popScope() on the topmost scope", .{});
     }
 
     pub fn markExprAsParenthesized(p: *P, expr: *Expr) void {
@@ -5544,6 +5780,253 @@ const P = struct {
         return p._parsePrefix(level, errors orelse &DeferredErrors.None, flags);
     }
 
+    pub fn appendPart(p: *P, parts: List(js_ast.Part), stmts: []Stmt) !void {
+        p.symbol_uses = SymbolUseMap.init(p.allocator);
+        p.declared_symbols.deinit();
+        p.import_records_for_current_part.deinit();
+        p.scopes_for_current_part.deinit();
+        var opts = PrependTempRefsOpts{};
+        var partStmts = List(Stmt).fromOwnedSlice(p.allocator, stmts);
+        try p.visitStmtsAndPrependTempRefs(&partStmts, &opts);
+
+        // Insert any relocated variable statements now
+        if (p.relocated_top_level_vars.items.len > 0) {
+            var already_declared = RefBoolMap.init(p.allocator);
+
+            // Follow links because "var" declarations may be merged due to hoisting
+
+            // while (true) {
+            //     const link = p.symbols.items[local.ref.inner_index].link;
+            // }
+        }
+        // TODO: here
+    }
+
+    pub fn visitStmtsAndPrependTempRefs(p: *P, stmts: *List(Stmt), opts: *PrependTempRefsOpts) !void {
+        var old_temp_refs = p.temp_refs_to_declare;
+        var old_temp_ref_count = p.temp_ref_count;
+        p.temp_refs_to_declare.deinit();
+        p.temp_refs_to_declare = @TypeOf(p.temp_refs_to_declare).init(p.allocator);
+        p.temp_ref_count = 0;
+
+        try p.visitStmts(stmts, opts.kind);
+
+        // Prepend values for "this" and "arguments"
+        if (opts.fn_body_loc != null) {
+            // Capture "this"
+            if (p.fn_only_data_visit.this_capture_ref) |ref| {
+                try p.temp_refs_to_declare.append(TempRef{
+                    .ref = ref,
+                    .value = p.e(E.This{}, opts.fn_body_loc orelse std.debug.panic("Internal error: Expected opts.fn_body_loc to exist", .{})),
+                });
+            }
+        }
+    }
+
+    pub fn recordDeclaredSymbol(p: *P, ref: Ref) !void {
+        try p.declared_symbols.append(js_ast.DeclaredSymbol{
+            .ref = ref,
+            .is_top_level = p.current_scope == p.module_scope,
+        });
+    }
+
+    pub fn visitExpr(p: *P, expr: Expr) Expr {
+        return p.visitExprInOut(expr, in);
+    }
+
+    pub fn visitExprInOut(p: *P, expr: Expr, in: ExprIn) Expr {}
+
+    pub fn visitAndAppendStmt(p: *P, stmts: *List(Stmt), stmt: *Stmt) !void {
+        switch (stmt.data) {
+            // These don't contain anything to traverse
+
+            .s_debugger, .s_empty, .s_comment => {},
+            .s_type_script => |data| {
+                // Erase TypeScript constructs from the output completely
+                return;
+            },
+            .s_directive => |data| {
+                //         	if p.isStrictMode() && s.LegacyOctalLoc.Start > 0 {
+                // 	p.markStrictModeFeature(legacyOctalEscape, p.source.RangeOfLegacyOctalEscape(s.LegacyOctalLoc), "")
+                // }
+                return;
+            },
+            .s_import => |data| {
+                try p.recordDeclaredSymbol(data.namespace_ref);
+
+                if (data.default_name) |default_name| {
+                    try p.recordDeclaredSymbol(default_name.ref orelse unreachable);
+                }
+
+                if (data.items.len > 0) {
+                    for (data.items) |*item| {
+                        try p.recordDeclaredSymbol(item.name.ref orelse unreachable);
+                    }
+                }
+            },
+            .s_export_clause => |data| {
+                // "export {foo}"
+                var end: usize = 0;
+                for (data.items) |*item| {
+                    const name = p.loadNameFromRef(item.name.ref orelse unreachable);
+                    const symbol = try p.findSymbol(item.alias_loc, name);
+                    const ref = symbol.ref;
+
+                    if (p.symbols.items[ref.inner_index].kind == .unbound) {
+                        // Silently strip exports of non-local symbols in TypeScript, since
+                        // those likely correspond to type-only exports. But report exports of
+                        // non-local symbols as errors in JavaScript.
+                        if (!p.options.ts) {
+                            const r = js_lexer.rangeOfIdentifier(&p.source, item.name.loc);
+                            try p.log.addRangeErrorFmt(p.source, r, p.allocator, "\"{s}\" is not declared in this file", .{name});
+                            continue;
+                        }
+                        continue;
+                    }
+
+                    item.name.ref = ref;
+                    data.items[end] = item.*;
+                    end += 1;
+                }
+                // esbuild: "Note: do not remove empty export statements since TypeScript uses them as module markers"
+                // jarred: does that mean we can remove them here, since we're not bundling for production?
+                data.items = data.items[0..end];
+            },
+            .s_export_from => |data| {
+                // "export {foo} from 'path'"
+                const name = p.loadNameFromRef(data.namespace_ref);
+                data.namespace_ref = try p.newSymbol(.other, name);
+                try p.current_scope.generated.append(data.namespace_ref);
+                try p.recordDeclaredSymbol(data.namespace_ref);
+
+                // This is a re-export and the symbols created here are used to reference
+                for (data.items) |*item| {
+                    const _name = p.loadNameFromRef(item.name.ref orelse unreachable);
+                    const ref = try p.newSymbol(.other, _name);
+                    try p.current_scope.generated.append(data.namespace_ref);
+                    try p.recordDeclaredSymbol(data.namespace_ref);
+                    item.name.ref = ref;
+                }
+            },
+            .s_export_star => |data| {
+                // "export {foo} from 'path'"
+                const name = p.loadNameFromRef(data.namespace_ref);
+                data.namespace_ref = try p.newSymbol(.other, name);
+                try p.current_scope.generated.append(data.namespace_ref);
+                try p.recordDeclaredSymbol(data.namespace_ref);
+
+                // "export * as ns from 'path'"
+                if (data.alias) |alias| {
+                    // "import * as ns from 'path'"
+                    // "export {ns}"
+
+                    // jarred: For now, just always do this transform.
+                    // because Safari doesn't support it and I've seen cases where this breaks
+                    // TODO: backport unsupportedJSFeatures map
+                    p.recordUsage(&data.namespace_ref);
+                    try stmts.ensureCapacity(stmts.items.len + 2);
+                    stmts.appendAssumeCapacity(p.s(S.Import{ .namespace_ref = data.namespace_ref, .star_name_loc = alias.loc, .import_record_index = data.import_record_index }, stmt.loc));
+
+                    var items = try List(js_ast.ClauseItem).initCapacity(p.allocator, 1);
+                    items.appendAssumeCapacity(js_ast.ClauseItem{ .alias = alias.original_name, .original_name = alias.original_name, .alias_loc = alias.loc, .name = LocRef{ .loc = alias.loc, .ref = data.namespace_ref } });
+                    stmts.appendAssumeCapacity(p.s(S.ExportClause{ .items = items.toOwnedSlice(), .is_single_line = true }, stmt.loc));
+                }
+            },
+            .s_export_default => |data| {
+                try p.recordDeclaredSymbol(data.default_name.ref orelse unreachable);
+
+                switch (data.value) {
+                    .expr => |*expr| {
+                        const was_anonymous_named_expr = expr.isAnonymousNamed();
+                        data.value.expr = p.m(p.visitExpr(expr));
+
+                        // Optionally preserve the name
+                        data.value.expr = p.maybeKeepExprSymbolName(expr, "default", was_anonymous_named_expr);
+
+                        // Discard type-only export default statements
+                        if (p.options.ts) {
+                            switch (expr.data) {
+                                .e_identifier => |ident| {
+                                    const symbol = p.symbols.items[ident.ref.inner_index];
+                                    if (symbol.kind == .unbound) {
+                                        if (p.local_type_names.get(symbol.original_name)) |local_type| {
+                                            if (local_type.value) {
+                                                return;
+                                            }
+                                        }
+                                    }
+                                },
+                                else => {},
+                            }
+                        }
+                    },
+
+                    .stmt => |st| {},
+                }
+            },
+            .s_export_equals => |data| {},
+            .s_break => |data| {},
+            .s_continue => |data| {},
+            .s_label => |data| {},
+            .s_local => |data| {},
+            .s_expr => |data| {},
+            .s_throw => |data| {},
+            .s_return => |data| {},
+            .s_block => |data| {},
+            .s_with => |data| {},
+            .s_while => |data| {},
+            .s_do_while => |data| {},
+            .s_if => |data| {},
+            .s_for => |data| {},
+            .s_for_in => |data| {},
+            .s_for_of => |data| {},
+            .s_try => |data| {},
+            .s_switch => |data| {},
+            .s_function => |data| {},
+            .s_class => |data| {},
+            .s_enum => |data| {},
+            .s_namespace => |data| {},
+            else => {},
+        }
+
+        // if we get this far, it stays
+        try stmts.append(stmt.*);
+    }
+
+    fn visitStmts(p: *P, stmts: *List(Stmt), kind: StmtsKind) !void {
+        // Save the current control-flow liveness. This represents if we are
+        // currently inside an "if (false) { ... }" block.
+        var old_is_control_flow_dead = p.is_control_flow_dead;
+
+        // visit all statements first
+        var visited = try List(Stmt).initCapacity(p.allocator, stmts.items.len);
+        var before = List(Stmt).init(p.allocator);
+        var after = List(Stmt).init(p.allocator);
+        for (stmts.items) |*stmt| {
+            switch (stmt.data) {
+                .s_export_equals => {
+                    // TypeScript "export = value;" becomes "module.exports = value;". This
+                    // must happen at the end after everything is parsed because TypeScript
+                    // moves this statement to the end when it generates code.
+                    try p.visitAndAppendStmt(&after, stmt);
+                    continue;
+                },
+                .s_function => |data| {
+                    // Manually hoist block-level function declarations to preserve semantics.
+                    // This is only done for function declarations that are not generators
+                    // or async functions, since this is a backwards-compatibility hack from
+                    // Annex B of the JavaScript standard.
+                    if (!p.current_scope.kindStopsHoisting() and p.symbols.items[data.func.name.?.ref.?.inner_index].kind == .hoisted_function) {
+                        try p.visitAndAppendStmt(&before, stmt);
+                        continue;
+                    }
+                },
+                else => {},
+            }
+            try p.visitAndAppendStmt(&visited, stmt);
+        }
+    }
+
     fn extractDeclsForBinding(binding: Binding, decls: *List(G.Decl)) !void {
         switch (binding.data) {
             .b_property, .b_missing => {},
diff --git a/src/logger.zig b/src/logger.zig
index 634064086..47253728c 100644
--- a/src/logger.zig
+++ b/src/logger.zig
@@ -178,6 +178,14 @@ pub const Log = struct {
         });
     }
 
+    pub fn addWarning(log: *Log, source: ?Source, l: Loc, text: string) !void {
+        log.warnings += 1;
+        try log.addMsg(Msg{
+            .kind = .warn,
+            .data = rangeData(source, Range{ .loc = l }, text),
+        });
+    }
+
     pub fn addRangeDebug(log: *Log, source: ?Source, r: Range, text: string) !void {
         try log.addMsg(Msg{
             .kind = .debug,