feat: add const enum semantic data

Author: IWANABETHATGUY

Cargo.lock

@@ -20,6 +20,7 @@ workspace = true
 doctest = true
 
 [dependencies]
+num-bigint = { workspace = true }
 oxc_allocator = { workspace = true }
 oxc_ast = { workspace = true }
 oxc_ast_visit = { workspace = true }

crates/oxc_semantic/Cargo.toml

@@ -5,6 +5,8 @@ use std::{
     mem,
 };
 
+use num_bigint::BigInt;
+
 use rustc_hash::FxHashMap;
 
 use oxc_allocator::Address;
@@ -27,6 +29,7 @@ use oxc_syntax::{
 #[cfg(feature = "linter")]
 use crate::jsdoc::JSDocBuilder;
 use crate::{
+    const_enum::{ConstEnumTable, ConstEnumMemberValue, ConstEnumMemberInfo, ConstEnumInfo},
     Semantic,
     binder::{Binder, ModuleInstanceState},
     checker,
@@ -108,6 +111,9 @@ pub struct SemanticBuilder<'a> {
 
     pub(crate) class_table_builder: ClassTableBuilder<'a>,
 
+    /// Table for storing const enum information
+    pub(crate) const_enum_table: ConstEnumTable<'a>,
+
     #[cfg(feature = "cfg")]
     ast_node_records: Vec<NodeId>,
 }
@@ -154,6 +160,7 @@ impl<'a> SemanticBuilder<'a> {
             #[cfg(not(feature = "cfg"))]
             cfg: (),
             class_table_builder: ClassTableBuilder::new(),
+            const_enum_table: ConstEnumTable::new(),
             #[cfg(feature = "cfg")]
             ast_node_records: Vec::new(),
         }
@@ -296,6 +303,7 @@ impl<'a> SemanticBuilder<'a> {
             nodes: self.nodes,
             scoping: self.scoping,
             classes: self.class_table_builder.build(),
+            const_enums: self.const_enum_table,
             #[cfg(feature = "linter")]
             jsdoc,
             unused_labels: self.unused_labels.labels,
@@ -2146,7 +2154,11 @@ impl<'a> SemanticBuilder<'a> {
             }
             AstKind::TSEnumDeclaration(enum_declaration) => {
                 enum_declaration.bind(self);
-                // TODO: const enum?
+
+                // Process const enums
+                if enum_declaration.r#const {
+                    self.process_const_enum(enum_declaration);
+                }
             }
             AstKind::TSEnumMember(enum_member) => {
                 enum_member.bind(self);
@@ -2232,4 +2244,209 @@ impl<'a> SemanticBuilder<'a> {
             mem::take(&mut self.current_reference_flags)
         }
     }
+
+    /// Process a const enum declaration and evaluate its members
+    fn process_const_enum(&mut self, enum_declaration: &TSEnumDeclaration<'a>) {
+        // Get the symbol ID for this enum
+        let symbol_id = enum_declaration.id.symbol_id.get().expect("enum should have symbol ID");
+
+        let mut members = std::collections::HashMap::new();
+        let mut current_value: f64 = -1.0; // Start at -1, first auto-increment will make it 0
+
+        for member in &enum_declaration.body.members {
+            let member_name = match &member.id {
+                TSEnumMemberName::Identifier(ident) => ident.name.as_str(),
+                TSEnumMemberName::String(string) => string.value.as_str(),
+                TSEnumMemberName::ComputedString(string) => string.value.as_str(),
+                TSEnumMemberName::ComputedTemplateString(template) => {
+                    // For computed template strings, we need to evaluate them
+                    if template.expressions.is_empty() {
+                        if let Some(quasi) = template.quasis.first() {
+                            quasi.value.raw.as_str()
+                        } else {
+                            continue;
+                        }
+                    } else {
+                        // Skip template literals with expressions for now
+                        continue;
+                    }
+                }
+            };
+
+            let value = if let Some(initializer) = &member.initializer {
+                // Evaluate the initializer expression
+                let mut visited = std::vec::Vec::new();
+                if let Some(evaluated_value) = self.evaluate_const_enum_member(initializer, Some(symbol_id), &mut visited) {
+                    // Update current_value based on the evaluated value
+                    match &evaluated_value {
+                        ConstEnumMemberValue::Number(n) => current_value = *n,
+                        _ => {} // Don't change current_value for non-numeric values
+                    }
+                    evaluated_value
+                } else {
+                    // If evaluation fails, fall back to current_value + 1
+                    current_value += 1.0;
+                    ConstEnumMemberValue::Number(current_value)
+                }
+            } else {
+                // Auto-increment the value
+                current_value += 1.0;
+                ConstEnumMemberValue::Number(current_value)
+            };
+
+            let member_info = ConstEnumMemberInfo {
+                name: member_name,
+                value,
+                span: member.span,
+                has_initializer: member.initializer.is_some(),
+            };
+
+            members.insert(member_name, member_info);
+        }
+
+        let enum_info = ConstEnumInfo {
+            symbol_id,
+            members,
+            span: enum_declaration.span,
+        };
+
+        self.const_enum_table.add_enum(symbol_id, enum_info);
+    }
+
+    /// Evaluate a const enum member's value with improved JavaScript semantics
+    fn evaluate_const_enum_member(
+        &self,
+        expression: &Expression<'a>,
+        current_enum: Option<SymbolId>,
+        _visited: &mut std::vec::Vec<&'a str>,
+    ) -> Option<ConstEnumMemberValue<'a>> {
+        match expression {
+            Expression::StringLiteral(string) => Some(ConstEnumMemberValue::String(string.value.as_str())),
+            Expression::NumericLiteral(number) => Some(ConstEnumMemberValue::Number(number.value)),
+            Expression::BooleanLiteral(boolean) => Some(ConstEnumMemberValue::Boolean(boolean.value)),
+            Expression::BigIntLiteral(bigint) => {
+                bigint.value.parse::<BigInt>().ok().map(ConstEnumMemberValue::BigInt)
+            }
+            Expression::UnaryExpression(unary) => {
+                if let Some(argument) = self.evaluate_const_enum_member(&unary.argument, current_enum, _visited) {
+                    self.evaluate_unary_operation(unary, argument)
+                } else {
+                    None
+                }
+            }
+            Expression::BinaryExpression(binary) => {
+                if let (Some(left), Some(right)) = (
+                    self.evaluate_const_enum_member(&binary.left, current_enum, _visited),
+                    self.evaluate_const_enum_member(&binary.right, current_enum, _visited),
+                ) {
+                    self.evaluate_binary_operation(binary, left, right)
+                } else {
+                    None
+                }
+            }
+            Expression::Identifier(ident) => {
+                // Try to resolve this as a reference to another const enum member
+                let name = ident.name.as_str();
+
+                if let Some(current_enum_id) = current_enum {
+                    if let Some(enum_info) = self.const_enum_table.get_enum(current_enum_id) {
+                        if let Some(member_info) = enum_info.members.get(name) {
+                            return Some(member_info.value.clone());
+                        }
+                    }
+                }
+                None
+            }
+            _ => None,
+        }
+    }
+
+    /// Evaluate unary operations with proper JavaScript semantics
+    fn evaluate_unary_operation(
+        &self,
+        unary: &UnaryExpression<'a>,
+        argument: ConstEnumMemberValue<'a>,
+    ) -> Option<ConstEnumMemberValue<'a>> {
+        match unary.operator {
+            UnaryOperator::UnaryNegation => {
+                match argument {
+                    ConstEnumMemberValue::Number(n) => Some(ConstEnumMemberValue::Number(-n)),
+                    _ => None,
+                }
+            }
+            UnaryOperator::UnaryPlus => {
+                match argument {
+                    ConstEnumMemberValue::Number(n) => Some(ConstEnumMemberValue::Number(n)),
+                    _ => None,
+                }
+            }
+            UnaryOperator::LogicalNot => {
+                match argument {
+                    ConstEnumMemberValue::Boolean(b) => Some(ConstEnumMemberValue::Boolean(!b)),
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
+
+    /// Evaluate binary operations with proper JavaScript semantics
+    fn evaluate_binary_operation(
+        &self,
+        binary: &BinaryExpression<'a>,
+        left: ConstEnumMemberValue<'a>,
+        right: ConstEnumMemberValue<'a>,
+    ) -> Option<ConstEnumMemberValue<'a>> {
+        match binary.operator {
+            BinaryOperator::Addition => {
+                match (&left, &right) {
+                    (ConstEnumMemberValue::Number(l), ConstEnumMemberValue::Number(r)) => {
+                        Some(ConstEnumMemberValue::Number(l + r))
+                    }
+                    _ => None,
+                }
+            }
+            BinaryOperator::Subtraction => {
+                match (&left, &right) {
+                    (ConstEnumMemberValue::Number(l), ConstEnumMemberValue::Number(r)) => {
+                        Some(ConstEnumMemberValue::Number(l - r))
+                    }
+                    _ => None,
+                }
+            }
+            BinaryOperator::Multiplication => {
+                match (&left, &right) {
+                    (ConstEnumMemberValue::Number(l), ConstEnumMemberValue::Number(r)) => {
+                        Some(ConstEnumMemberValue::Number(l * r))
+                    }
+                    _ => None,
+                }
+            }
+            BinaryOperator::Division => {
+                match (&left, &right) {
+                    (ConstEnumMemberValue::Number(l), ConstEnumMemberValue::Number(r)) => {
+                        if *r == 0.0 { None } else { Some(ConstEnumMemberValue::Number(l / r)) }
+                    }
+                    _ => None,
+                }
+            }
+            BinaryOperator::ShiftLeft => {
+                match (&left, &right) {
+                    (ConstEnumMemberValue::Number(l), ConstEnumMemberValue::Number(r)) => {
+                        Some(ConstEnumMemberValue::Number(((*l as i64) << (*r as i64)) as f64))
+                    }
+                    _ => None,
+                }
+            }
+            BinaryOperator::BitwiseOR => {
+                match (&left, &right) {
+                    (ConstEnumMemberValue::Number(l), ConstEnumMemberValue::Number(r)) => {
+                        Some(ConstEnumMemberValue::Number(((*l as i64) | (*r as i64)) as f64))
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        }
+    }
 }

crates/oxc_semantic/src/builder.rs

@@ -0,0 +1,110 @@
+//! Const enum value evaluation and storage
+//!
+//! This module provides functionality for evaluating and storing const enum values
+//! during semantic analysis. Const enums are compiled away and their members are
+//! inlined as literal values.
+
+use std::collections::HashMap;
+use num_bigint::BigInt;
+use oxc_span::Span;
+use oxc_syntax::symbol::SymbolId;
+
+/// Represents a computed const enum member value
+#[derive(Debug, Clone)]
+pub enum ConstEnumMemberValue<'a> {
+    /// String literal value
+    String(&'a str),
+    /// Numeric literal value (f64 to handle both integers and floats)
+    Number(f64),
+    /// BigInt value
+    BigInt(BigInt),
+    /// Boolean value
+    Boolean(bool),
+    /// Computed value from other enum members (not stored for now)
+    Computed,
+}
+
+impl<'a> PartialEq for ConstEnumMemberValue<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::String(l), Self::String(r)) => l == r,
+            (Self::Number(l), Self::Number(r)) => l == r,
+            (Self::BigInt(l), Self::BigInt(r)) => l == r,
+            (Self::Boolean(l), Self::Boolean(r)) => l == r,
+            (Self::Computed, Self::Computed) => true,
+            _ => false,
+        }
+    }
+}
+
+/// Information about a const enum member
+#[derive(Debug, Clone)]
+pub struct ConstEnumMemberInfo<'a> {
+    /// Name of the enum member
+    pub name: &'a str,
+    /// Computed value of the member
+    pub value: ConstEnumMemberValue<'a>,
+    /// Span of the member declaration
+    pub span: Span,
+    /// Whether this member has an explicit initializer
+    pub has_initializer: bool,
+}
+
+/// Information about a const enum
+#[derive(Debug, Clone)]
+pub struct ConstEnumInfo<'a> {
+    /// Symbol ID of the const enum
+    pub symbol_id: SymbolId,
+    /// Members of the const enum
+    pub members: HashMap<&'a str, ConstEnumMemberInfo<'a>>,
+    /// Span of the enum declaration
+    pub span: Span,
+}
+
+/// Storage for all const enum information in a program
+#[derive(Debug, Default, Clone)]
+pub struct ConstEnumTable<'a> {
+    /// Map of const enum symbol IDs to their information
+    pub enums: HashMap<SymbolId, ConstEnumInfo<'a>>,
+}
+
+impl<'a> ConstEnumTable<'a> {
+    /// Create a new const enum table
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add a const enum to the table
+    pub fn add_enum(&mut self, symbol_id: SymbolId, enum_info: ConstEnumInfo<'a>) {
+        self.enums.insert(symbol_id, enum_info);
+    }
+
+    /// Get const enum information by symbol ID
+    pub fn get_enum(&self, symbol_id: SymbolId) -> Option<&ConstEnumInfo<'a>> {
+        self.enums.get(&symbol_id)
+    }
+
+    /// Get a const enum member value
+    pub fn get_member_value(
+        &self,
+        symbol_id: SymbolId,
+        member_name: &str,
+    ) -> Option<&ConstEnumMemberValue<'a>> {
+        self.enums
+            .get(&symbol_id)
+            .and_then(|enum_info| enum_info.members.get(member_name))
+            .map(|member| &member.value)
+    }
+
+    /// Check if a symbol represents a const enum
+    pub fn is_const_enum(&self, symbol_id: SymbolId) -> bool {
+        self.enums.contains_key(&symbol_id)
+    }
+
+    /// Get all const enums
+    pub fn enums(&self) -> impl Iterator<Item = (&SymbolId, &ConstEnumInfo<'a>)> {
+        self.enums.iter()
+    }
+}
+
+