Skip to main content

turbopack_ecmascript/references/
constant_condition.rs

1use anyhow::Result;
2use bincode::{Decode, Encode};
3use swc_core::quote;
4use turbo_tasks::{NonLocalValue, Vc, debug::ValueDebugFormat};
5use turbopack_core::chunk::ChunkingContext;
6
7use crate::{
8    ast_path_trie::{AstPathId, AstPathTrie},
9    code_gen::{CodeGen, CodeGeneration},
10    create_visitor,
11};
12
13#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug, NonLocalValue, Encode, Decode)]
14pub enum ConstantConditionValue {
15    Truthy,
16    Falsy,
17    Nullish,
18}
19
20#[derive(PartialEq, Eq, ValueDebugFormat, NonLocalValue, Debug, Hash, Encode, Decode)]
21pub struct ConstantConditionCodeGen {
22    value: ConstantConditionValue,
23    path: AstPathId,
24}
25
26impl ConstantConditionCodeGen {
27    pub fn new(value: ConstantConditionValue, path: AstPathId) -> Self {
28        ConstantConditionCodeGen { value, path }
29    }
30
31    pub async fn code_generation(
32        &self,
33        _trie: &AstPathTrie,
34        _chunking_context: Vc<Box<dyn ChunkingContext>>,
35    ) -> Result<CodeGeneration> {
36        let value = self.value;
37        let visitors = [create_visitor!(
38            exact,
39            trie,
40            self.path,
41            visit_mut_expr,
42            |expr: &mut Expr| {
43                *expr = match value {
44                    ConstantConditionValue::Truthy => {
45                        quote!("(\"TURBOPACK compile-time truthy\", 1)" as Expr)
46                    }
47                    ConstantConditionValue::Falsy => {
48                        quote!("(\"TURBOPACK compile-time falsy\", 0)" as Expr)
49                    }
50                    ConstantConditionValue::Nullish => {
51                        quote!("(\"TURBOPACK compile-time nullish\", null)" as Expr)
52                    }
53                };
54            }
55        )]
56        .into();
57
58        Ok(CodeGeneration::visitors(visitors))
59    }
60}
61
62impl From<ConstantConditionCodeGen> for CodeGen {
63    fn from(val: ConstantConditionCodeGen) -> Self {
64        CodeGen::ConstantConditionCodeGen(val)
65    }
66}