feat(oxc_semantic): collect const enum information with basic const eval

[IWANABETHATGUY]

related to #11844, #6073

[IWANABETHATGUY]

• feat(oxc_semantic): collect const enum information with basic const eval #15192 👈 (View in Graphite)
• main

---

How to use the Graphite Merge Queue

Add either label to this PR to merge it via the merge queue:

• 0-merge - adds this PR to the back of the merge queue
• hotfix - for urgent hot fixes, skip the queue and merge this PR next

You must have a Graphite account in order to use the merge queue. Sign up using this link.

An organization admin has enabled the Graphite Merge Queue in this repository.

Please do not merge from GitHub as this will restart CI on PRs being processed by the merge queue.

This stack of pull requests is managed by Graphite. Learn more about stacking.

[codspeed-hq]

CodSpeed Performance Report

Merging #15192 will not alter performance

_{Comparing 10-31-feat_add_const_enum_semantic_data (a9c163a) with main (b5d6360)}

Summary

✅ 37 untouched

[IWANABETHATGUY]

Cannot reuse allocator in scoping since Trait

oxc/crates/oxc_semantic/src/const_enum.rs

Lines 188 to 192 in 0653e9f

	impl<'a> ConstantEvaluationCtx<'a> for ConstantEnumCtx<'_, 'a> {
	fn ast(&self) -> oxc_ast::AstBuilder<'a> {
	self.builder
	}
	}

only has an immutable self reference; we can't access Allocator inside scoping without a mutable reference. If we create an AstBuilder with an arena inside a scope, that would violate Rustc's borrow rules.

[IWANABETHATGUY]

Use a temp AstBuilder to satisfy ConstantEvaluationCtx

oxc/crates/oxc_semantic/src/const_enum.rs

Lines 188 to 192 in 0653e9f

	impl<'a> ConstantEvaluationCtx<'a> for ConstantEnumCtx<'_, 'a> {
	fn ast(&self) -> oxc_ast::AstBuilder<'a> {
	self.builder
	}
	}

, since the lifetime did not live long enough, we need to convert the arena-based ConstValue into a heap-allocated version finally.

[IWANABETHATGUY]

This is because the current

oxc/crates/oxc_ecmascript/src/constant_evaluation/mod.rs

Lines 212 to 236 in d8881ae

	BinaryOperator::Addition => {
	use crate::to_primitive::ToPrimitive;
	let left_to_primitive = left.to_primitive(ctx);
	let right_to_primitive = right.to_primitive(ctx);
	if left_to_primitive.is_string() == Some(true)
	|| right_to_primitive.is_string() == Some(true)
	{
	let lval = left.evaluate_value_to_string(ctx)?;
	let rval = right.evaluate_value_to_string(ctx)?;
	return Some(ConstantValue::String(lval + rval));
	}
	let left_to_numeric_type = left_to_primitive.to_numeric(ctx);
	let right_to_numeric_type = right_to_primitive.to_numeric(ctx);
	if left_to_numeric_type.is_number() || right_to_numeric_type.is_number() {
	let lval = left.evaluate_value_to_number(ctx)?;
	let rval = right.evaluate_value_to_number(ctx)?;
	return Some(ConstantValue::Number(lval + rval));
	}
	if left_to_numeric_type.is_bigint() && right_to_numeric_type.is_bigint() {
	let lval = left.evaluate_value_to_bigint(ctx)?;
	let rval = right.evaluate_value_to_bigint(ctx)?;
	return Some(ConstantValue::BigInt(lval + rval));
	}
	None
	}

does not support the scenario where an identifier reference points to a const value.

[IWANABETHATGUY]

This is because the current constEval did not support resolving a memberExpr

[Copilot]

Pull Request Overview

This PR adds support for const enum value evaluation and storage during semantic analysis. Const enums are a TypeScript feature where enum members are compiled away and inlined as literal values at compile time.

• Adds a new ConstEnumTable to store evaluated const enum member values
• Implements constant evaluation logic for enum members including auto-increment, literals, and expressions
• Integrates const enum processing into the semantic analysis phase

Reviewed Changes

Copilot reviewed 6 out of 7 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
crates/oxc_semantic/tests/integration/main.rs	Adds const_enum module to test suite
crates/oxc_semantic/tests/integration/const_enum.rs	Comprehensive test suite for const enum evaluation including simple enums, explicit values, mixed values, literals, binary expressions, and constant propagation
crates/oxc_semantic/src/lib.rs	Exposes const enum types and adds const_enums field to Semantic struct with accessor methods
crates/oxc_semantic/src/const_enum.rs	Core implementation of const enum evaluation logic and storage structures
crates/oxc_semantic/src/builder.rs	Integrates const enum processing into the semantic builder's AST traversal
crates/oxc_semantic/Cargo.toml	Adds num-bigint dependency for BigInt support
Cargo.lock	Updates lock file with num-bigint dependency

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Dunqing]

Const enum evaluation is relatively simple because all member values should be a constant expression, such that these expressions can be evaluated at compile time. Therefore, I don't think we need to use ConstantEvaluationCtx here, as it leads to more complexity and is not suitable for the semantics.

Instead, we can reuse the current enum transformation in the https://github.com/oxc-project/oxc/blob/936983b7e60118c1090ab817cc49a9d6855a5b64/crates/oxc_transformer/src/typescript/enum.rs#L350-L65, which is a port version of TypeScript's implementation, so that we can keep consistent, and this implementation can solve the problems you mentioned.

[IWANABETHATGUY]

Const enum evaluation is relatively simple because all member values should be a constant expression, such that these expressions can be evaluated at compile time. Therefore, I don't think we need to use ConstantEvaluationCtx here, as it leads to more complexity and is not suitable for the semantics.

Instead, we can reuse the current enum transformation in the https://github.com/oxc-project/oxc/blob/936983b7e60118c1090ab817cc49a9d6855a5b64/crates/oxc_transformer/src/typescript/enum.rs#L350-L65, which is a port version of TypeScript's implementation, so that we can keep consistent, and this implementation can solve the problems you mentioned.

Thanks, I don't even know that exists, it solved my issue.