feat: warn for unknown env property

Author: intellild

crates/rspack_plugin_javascript/src/parser_plugin/import_meta_plugin.rs

@@ -8,7 +8,7 @@ use rspack_core::{
   RscModuleType, RuntimeGlobals, RuntimeRequirementsDependency, property_access,
 };
 use rspack_error::{Error, Severity};
-use rspack_util::SpanExt;
+use rspack_util::{SpanExt, fx_hash::FxDashSet};
 use swc_atoms::Atom;
 use swc_experimental_ecma_ast::{
   AssignExpr, CallExpr, Expr, GetSpan, MemberExpr, MemberProp, MetaPropKind, Span, UnaryExpr,
@@ -340,6 +340,7 @@ pub struct ImportMetaPlugin {
   import_meta: ArcComputed<ResolvedModuleOptions, ImportMeta>,
   recurse_env: AtomicBool,
   recurse_env_typeof: AtomicBool,
+  unknown_env_warning_spans: FxDashSet<(u32, u32)>,
 }
 
 impl ImportMetaPlugin {
@@ -348,6 +349,7 @@ impl ImportMetaPlugin {
       import_meta,
       recurse_env: AtomicBool::new(false),
       recurse_env_typeof: AtomicBool::new(false),
+      unknown_env_warning_spans: Default::default(),
     }
   }
 
@@ -382,6 +384,32 @@ impl ImportMetaPlugin {
       && self.known_property_enabled(ImportMetaKnownProperties::ENV)
   }
 
+  fn add_undefined_import_meta_env_warning(
+    &self,
+    parser: &mut JavascriptParser,
+    for_name: &str,
+    member_expr_info: Option<&ExpressionExpressionInfo>,
+    start: u32,
+    end: u32,
+  ) {
+    if !self.unknown_env_warning_spans.insert((start, end)) {
+      return;
+    }
+
+    let name = member_expr_info.map_or_else(
+      || for_name.to_string(),
+      |info| concat_string!("import.meta", property_access(info.members.iter(), 0)),
+    );
+    let mut warning = create_traceable_error(
+      "Undefined environment variable".into(),
+      format!("Environment variable {name} is not defined."),
+      parser.source.to_string(),
+      (start, end).into(),
+    );
+    warning.severity = Severity::Warning;
+    parser.add_warning(warning.into());
+  }
+
   fn evaluate_import_meta_env_identifier<'p>(
     &self,
     parser: &mut JavascriptParser<'p>,
@@ -399,6 +427,7 @@ impl ImportMetaPlugin {
     let Some(code) =
       member_expr_info.and_then(|info| render_import_meta_env_expression_info(parser, info, start))
     else {
+      self.add_undefined_import_meta_env_warning(parser, for_name, member_expr_info, start, end);
       return Some(eval::evaluate_to_undefined(start, end));
     };
     if self.recurse_env.swap(true, Ordering::Acquire) {
@@ -431,6 +460,7 @@ impl ImportMetaPlugin {
     let Some(code) =
       member_expr_info.and_then(|info| render_import_meta_env_expression_info(parser, info, start))
     else {
+      self.add_undefined_import_meta_env_warning(parser, for_name, member_expr_info, start, end);
       return Some(eval::evaluate_to_string(
         "undefined".to_string(),
         start,
@@ -937,6 +967,18 @@ impl<'p, 'a> JavascriptParserPlugin<'p, 'a> for ImportMetaPlugin {
       return None;
     }
 
+    if let Some(MemberExpressionInfo::Expression(info)) =
+      parser.get_member_expression_info(ExprRef::Member(expr), AllowedMemberTypes::Expression)
+    {
+      self.evaluate_import_meta_env_identifier(
+        parser,
+        &info.name,
+        Some(&info),
+        expr.span().real_lo(),
+        expr.span().real_hi(),
+      );
+    }
+
     add_import_meta_env_value_dependency(parser);
     let replacement = render_import_meta_env_member_chain(
       parser,
@@ -1040,6 +1082,13 @@ impl<'p, 'a> JavascriptParserPlugin<'p, 'a> for ImportMetaPlugin {
               .first()
               .is_some_and(|member| member == "env")
           {
+            self.evaluate_import_meta_env_identifier(
+              parser,
+              &members.name,
+              Some(members),
+              expr.span().real_lo(),
+              expr.span().real_hi(),
+            );
             add_import_meta_env_value_dependency(parser);
             let replacement = render_import_meta_env_member_chain(
               parser,

tests/rspack-test/configCases/plugins/import-meta-env/index.js

@@ -76,6 +76,14 @@ it("should treat import.meta.env.NOT_EXIST as falsy", () => {
 	}
 });
 
+it("should warn when typeof accesses an undefined env field", () => {
+	expect(typeof import.meta.env.TYPEOF_UNKNOWN).toBe("undefined");
+});
+
+it("should not warn for an env field explicitly defined as undefined", () => {
+	expect(import.meta.env.EXPLICIT_UNDEFINED).toBe(undefined);
+});
+
 it("should preserve whole-object import.meta.env definitions", () => {
 	const env = import.meta.env;
 	expect(env.MODE).toBe("production");

tests/rspack-test/configCases/plugins/import-meta-env/rspack.config.js

@@ -37,6 +37,7 @@ module.exports = {
         VALUE: JSON.stringify('object-form'),
       },
       'process.env.PROCESS_ONLY': JSON.stringify('process_only'),
+      'import.meta.env.EXPLICIT_UNDEFINED': 'undefined',
     }),
     new DefinePlugin({
       'import.meta.env.ORDERED_VAR': JSON.stringify('second_define_plugin'),

tests/rspack-test/configCases/plugins/import-meta-env/warnings.js

@@ -1,5 +1,10 @@
 "use strict";
 
 module.exports = [
-	/Conflicting values for 'import\.meta\.env\.ORDERED_VAR'/
+	/Conflicting values for 'import\.meta\.env\.ORDERED_VAR'/,
+	/Environment variable import\.meta\.env\.NOT_EXIST is not defined\./,
+	/Environment variable import\.meta\.env\.NOT_EXIST is not defined\./,
+	/Environment variable import\.meta\.env\.TYPEOF_UNKNOWN is not defined\./,
+	/Environment variable import\.meta\.env\.DOT\.KEY is not defined\./,
+	/Environment variable import\.meta\.env\.UNKNOWN is not defined\./
 ];