allow to pass constant values to free var references (vercel#4652)

### Description

This will allow to do constant replacements of free vars aka webpack
DefinePlugin

Author: sokra

crates/turbopack-core/src/compile_time_info.rs

@@ -1,15 +1,21 @@
 use std::collections::HashMap;
 
 use anyhow::Result;
-use serde::{Deserialize, Serialize};
-use turbo_tasks::trace::TraceRawVcs;
 use turbo_tasks_fs::FileSystemPathVc;
 
 use crate::environment::EnvironmentVc;
 
 // TODO stringify split map collect could be optimized with a marco
 #[macro_export]
 macro_rules! definable_name_map_internal {
+    ($map:ident, .. $value:expr) => {
+        for (key, value) in $value {
+            $map.insert(
+                key.into(),
+                value.into()
+            );
+        }
+    };
     ($map:ident, $($name:ident).+ = $value:expr) => {
         $map.insert(
             $crate::definable_name_map_internal!($($name).+).into(),
@@ -26,6 +32,10 @@ macro_rules! definable_name_map_internal {
         $crate::definable_name_map_internal!($map, $($name).+ = $value);
         $crate::definable_name_map_internal!($map, $($more)+);
     };
+    ($map:ident, .. $value:expr, $($more:tt)+) => {
+        $crate::definable_name_map_internal!($map, .. $value);
+        $crate::definable_name_map_internal!($map, $($more)+);
+    };
     ($name:ident) => {
         [stringify!($name).to_string()]
     };
@@ -62,7 +72,8 @@ macro_rules! free_var_references {
     };
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, TraceRawVcs)]
+#[turbo_tasks::value(serialization = "auto_for_input")]
+#[derive(Debug, Clone, Hash, PartialOrd, Ord)]
 pub enum CompileTimeDefineValue {
     Bool(bool),
     String(String),
@@ -89,6 +100,15 @@ impl From<&str> for CompileTimeDefineValue {
 #[turbo_tasks::value(transparent)]
 pub struct CompileTimeDefines(pub HashMap<Vec<String>, CompileTimeDefineValue>);
 
+impl IntoIterator for CompileTimeDefines {
+    type Item = (Vec<String>, CompileTimeDefineValue);
+    type IntoIter = std::collections::hash_map::IntoIter<Vec<String>, CompileTimeDefineValue>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl CompileTimeDefinesVc {
     #[turbo_tasks::function]
@@ -104,6 +124,31 @@ pub enum FreeVarReference {
         context: Option<FileSystemPathVc>,
         export: Option<String>,
     },
+    Value(CompileTimeDefineValue),
+}
+
+impl From<bool> for FreeVarReference {
+    fn from(value: bool) -> Self {
+        Self::Value(value.into())
+    }
+}
+
+impl From<String> for FreeVarReference {
+    fn from(value: String) -> Self {
+        Self::Value(value.into())
+    }
+}
+
+impl From<&str> for FreeVarReference {
+    fn from(value: &str) -> Self {
+        Self::Value(value.into())
+    }
+}
+
+impl From<CompileTimeDefineValue> for FreeVarReference {
+    fn from(value: CompileTimeDefineValue) -> Self {
+        Self::Value(value)
+    }
 }
 
 #[turbo_tasks::value(transparent)]

crates/turbopack-ecmascript/src/references/constant_value.rs

@@ -0,0 +1,51 @@
+use anyhow::Result;
+use swc_core::quote;
+use turbo_tasks::Value;
+use turbopack_core::compile_time_info::CompileTimeDefineValue;
+
+use super::AstPathVc;
+use crate::{
+    chunk::EcmascriptChunkingContextVc,
+    code_gen::{CodeGenerateable, CodeGenerateableVc, CodeGeneration, CodeGenerationVc},
+    create_visitor,
+};
+
+#[turbo_tasks::value]
+pub struct ConstantValue {
+    value: CompileTimeDefineValue,
+    path: AstPathVc,
+}
+
+#[turbo_tasks::value_impl]
+impl ConstantValueVc {
+    #[turbo_tasks::function]
+    pub fn new(value: Value<CompileTimeDefineValue>, path: AstPathVc) -> Self {
+        Self::cell(ConstantValue {
+            value: value.into_value(),
+            path,
+        })
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl CodeGenerateable for ConstantValue {
+    #[turbo_tasks::function]
+    async fn code_generation(
+        &self,
+        _context: EcmascriptChunkingContextVc,
+    ) -> Result<CodeGenerationVc> {
+        let value = self.value.clone();
+        let visitors = [
+            create_visitor!(exact &self.path.await?, visit_mut_expr(expr: &mut Expr) {
+                *expr = match value {
+                    CompileTimeDefineValue::Bool(true) => quote!("(\"TURBOPACK compile-time value\", true)" as Expr),
+                    CompileTimeDefineValue::Bool(false) => quote!("(\"TURBOPACK compile-time value\", false)" as Expr),
+                    CompileTimeDefineValue::String(ref s) => quote!("(\"TURBOPACK compile-time value\", $e)" as Expr, e: Expr = s.to_string().into()),
+                };
+            }),
+        ]
+        .into();
+
+        Ok(CodeGeneration { visitors }.cell())
+    }
+}

crates/turbopack-ecmascript/src/references/mod.rs

@@ -1,6 +1,7 @@
 pub mod amd;
 pub mod cjs;
 pub mod constant_condition;
+pub mod constant_value;
 pub mod esm;
 pub mod node;
 pub mod pattern_mapping;
@@ -20,6 +21,7 @@ use std::{
 
 use anyhow::Result;
 use constant_condition::{ConstantConditionValue, ConstantConditionVc};
+use constant_value::ConstantValueVc;
 use indexmap::IndexSet;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
@@ -1275,6 +1277,12 @@ pub(crate) async fn analyze_ecmascript_module(
                             .eq(name.iter().map(Cow::Borrowed).rev())
                         {
                             match value {
+                                FreeVarReference::Value(value) => {
+                                    analysis.add_code_gen(ConstantValueVc::new(
+                                        Value::new(value.clone()),
+                                        AstPathVc::cell(ast_path.to_vec()),
+                                    ));
+                                }
                                 FreeVarReference::EcmaScriptModule {
                                     request,
                                     context,