lists

2 files changed, 35 insertions, 29 deletions

diff --git a/src/resolver/package_json.zig b/src/resolver/package_json.zig
index 1594de702..a9952c8b1 100644
--- a/src/resolver/package_json.zig
+++ b/src/resolver/package_json.zig
@@ -79,8 +79,8 @@ pub const PackageJSON = struct {
             .main_fields = MainFieldMap.init(r.allocator),
         };
 
-        if (json.getProperty("type")) |type_json| {
-            if (type_json.expr.getString(r.allocator)) |type_str| {
+        if (json.asProperty("type")) |type_json| {
+            if (type_json.expr.asString(r.allocator)) |type_str| {
                 switch (options.ModuleType.List.get(type_str) orelse options.ModuleType.unknown) {
                     .cjs => {
                         package_json.module_type = .cjs;
@@ -105,10 +105,10 @@ pub const PackageJSON = struct {
 
         // Read the "main" fields
         for (r.opts.main_fields) |main| {
-            if (json.getProperty(main)) |main_json| {
+            if (json.asProperty(main)) |main_json| {
                 const expr: js_ast.Expr = main_json.expr;
 
-                if ((expr.getString(r.allocator))) |str| {
+                if ((expr.asString(r.allocator))) |str| {
                     if (str.len > 0) {
                         package_json.main_fields.put(main, str) catch unreachable;
                     }
@@ -129,14 +129,15 @@ pub const PackageJSON = struct {
             //     "./dist/index.node.esm.js": "./dist/index.browser.esm.js"
             //   },
             //
-            if (json.getProperty("browser")) |browser_prop| {
+            if (json.asProperty("browser")) |browser_prop| {
                 switch (browser_prop.expr.data) {
-                    .e_object => |obj| {
+                    .e_object => {
+                        const obj = browser_prop.expr.getObject();
                         // The value is an object
 
                         // Remap all files in the browser field
                         for (obj.properties) |prop| {
-                            var _key_str = (prop.key orelse continue).getString(r.allocator) orelse continue;
+                            var _key_str = (prop.key orelse continue).asString(r.allocator) orelse continue;
                             const value: js_ast.Expr = prop.value orelse continue;
 
                             // Normalize the path so we can compare against it without getting
@@ -151,11 +152,13 @@ pub const PackageJSON = struct {
                             const key = r.allocator.dupe(u8, r.fs.normalize(_key_str)) catch unreachable;
 
                             switch (value.data) {
-                                .e_string => |str| {
+                                .e_string => {
+                                    const str = value.getString();
                                     // If this is a string, it's a replacement package
                                     package_json.browser_map.put(key, str.string(r.allocator) catch unreachable) catch unreachable;
                                 },
-                                .e_boolean => |boolean| {
+                                .e_boolean => {
+                                    const boolean = value.getBoolean();
                                     if (!boolean.value) {
                                         package_json.browser_map.put(key, "") catch unreachable;
                                     }
diff --git a/src/resolver/tsconfig_json.zig b/src/resolver/tsconfig_json.zig
index 79fb6e677..7b6977bba 100644
--- a/src/resolver/tsconfig_json.zig
+++ b/src/resolver/tsconfig_json.zig
@@ -74,9 +74,9 @@ pub const TSConfigJSON = struct {
 
         var result: TSConfigJSON = TSConfigJSON{ .abs_path = source.key_path.text, .paths = PathsMap.init(allocator) };
         errdefer allocator.free(result.paths);
-        if (json.getProperty("extends")) |extends_value| {
+        if (json.asProperty("extends")) |extends_value| {
             log.addWarning(&source, extends_value.loc, "\"extends\" is not implemented yet") catch unreachable;
-            // if ((extends_value.expr.getString(allocator) catch null)) |str| {
+            // if ((extends_value.expr.asString(allocator) catch null)) |str| {
             //     if (extends(str, source.rangeOfString(extends_value.loc))) |base| {
             //         result.jsx = base.jsx;
             //         result.base_url_for_paths = base.base_url_for_paths;
@@ -90,48 +90,48 @@ pub const TSConfigJSON = struct {
         var has_base_url = false;
 
         // Parse "compilerOptions"
-        if (json.getProperty("compilerOptions")) |compiler_opts| {
+        if (json.asProperty("compilerOptions")) |compiler_opts| {
 
             // Parse "baseUrl"
-            if (compiler_opts.expr.getProperty("baseUrl")) |base_url_prop| {
-                if ((base_url_prop.expr.getString(allocator))) |base_url| {
+            if (compiler_opts.expr.asProperty("baseUrl")) |base_url_prop| {
+                if ((base_url_prop.expr.asString(allocator))) |base_url| {
                     result.base_url = base_url;
                     has_base_url = true;
                 }
             }
 
             // Parse "jsxFactory"
-            if (compiler_opts.expr.getProperty("jsxFactory")) |jsx_prop| {
-                if (jsx_prop.expr.getString(allocator)) |str| {
+            if (compiler_opts.expr.asProperty("jsxFactory")) |jsx_prop| {
+                if (jsx_prop.expr.asString(allocator)) |str| {
                     result.jsx.factory = try parseMemberExpressionForJSX(log, &source, jsx_prop.loc, str, allocator);
                 }
             }
 
             // Parse "jsxFragmentFactory"
-            if (compiler_opts.expr.getProperty("jsxFactory")) |jsx_prop| {
-                if (jsx_prop.expr.getString(allocator)) |str| {
+            if (compiler_opts.expr.asProperty("jsxFactory")) |jsx_prop| {
+                if (jsx_prop.expr.asString(allocator)) |str| {
                     result.jsx.fragment = try parseMemberExpressionForJSX(log, &source, jsx_prop.loc, str, allocator);
                 }
             }
 
             // Parse "jsxImportSource"
-            if (compiler_opts.expr.getProperty("jsxImportSource")) |jsx_prop| {
-                if (jsx_prop.expr.getString(allocator)) |str| {
+            if (compiler_opts.expr.asProperty("jsxImportSource")) |jsx_prop| {
+                if (jsx_prop.expr.asString(allocator)) |str| {
                     result.jsx.import_source = str;
                 }
             }
 
             // Parse "useDefineForClassFields"
-            if (compiler_opts.expr.getProperty("useDefineForClassFields")) |use_define_value_prop| {
-                if (use_define_value_prop.expr.getBool()) |val| {
+            if (compiler_opts.expr.asProperty("useDefineForClassFields")) |use_define_value_prop| {
+                if (use_define_value_prop.expr.asBool()) |val| {
                     result.use_define_for_class_fields = val;
                 }
             }
 
             // Parse "importsNotUsedAsValues"
-            if (compiler_opts.expr.getProperty("importsNotUsedAsValues")) |jsx_prop| {
+            if (compiler_opts.expr.asProperty("importsNotUsedAsValues")) |jsx_prop| {
                 // This should never allocate since it will be utf8
-                if ((jsx_prop.expr.getString(allocator))) |str| {
+                if ((jsx_prop.expr.asString(allocator))) |str| {
                     switch (ImportsNotUsedAsValue.List.get(str) orelse ImportsNotUsedAsValue.invalid) {
                         .preserve, .err => {
                             result.preserve_imports_not_used_as_values = true;
@@ -145,14 +145,15 @@ pub const TSConfigJSON = struct {
             }
 
             // Parse "paths"
-            if (compiler_opts.expr.getProperty("paths")) |paths_prop| {
+            if (compiler_opts.expr.asProperty("paths")) |paths_prop| {
                 switch (paths_prop.expr.data) {
-                    .e_object => |paths| {
+                    .e_object => {
+                        var paths = paths_prop.expr.getObject();
                         result.base_url_for_paths = result.base_url;
                         result.paths = PathsMap.init(allocator);
                         for (paths.properties) |property| {
                             const key_prop = property.key orelse continue;
-                            const key = (key_prop.getString(allocator)) orelse continue;
+                            const key = (key_prop.asString(allocator)) orelse continue;
 
                             if (!TSConfigJSON.isValidTSConfigPathNoBaseURLPattern(key, log, &source, allocator, key_prop.loc)) {
                                 continue;
@@ -182,13 +183,15 @@ pub const TSConfigJSON = struct {
                             // Matching "folder1/file2" should first check "projectRoot/folder1/file2"
                             // and then, if that didn't work, also check "projectRoot/generated/folder1/file2".
                             switch (value_prop.data) {
-                                .e_array => |array| {
+                                .e_array => {
+                                    const array = value_prop.getArray();
+
                                     if (array.items.len > 0) {
                                         var values = allocator.alloc(string, array.items.len) catch unreachable;
                                         errdefer allocator.free(values);
                                         var count: usize = 0;
                                         for (array.items) |expr| {
-                                            if ((expr.getString(allocator))) |str| {
+                                            if ((expr.asString(allocator))) |str| {
                                                 if (TSConfigJSON.isValidTSConfigPathPattern(
                                                     str,
                                                     log,