;")]
+#[case("import {tone} from './doc.mdx'; export const view=
;")]
+#[case("import Doc from './doc.mdx'; export const view=;")]
+#[case(
+ "import Doc from './doc.mdx'; const Alias=Doc; export {Alias}; export const view=;"
+)]
+#[serial]
+fn opaque_mdx_value_demand_still_reaches_the_authoritative_resolver(#[case] body: &str) {
+ // Given a resolver that records real attempted reads but supplies no Markdown.
+ let _state = crate::test_state::TestStateGuard::new();
+ let reads = RefCell::new(Vec::new());
+ let resolver = |source: &str, _: &str| {
+ reads.borrow_mut().push(source.to_string());
+ None
+ };
+ let code = format!("import {{Box}} from '@devup-ui/react'; {body}");
+ // When a binding is needed as a named primitive, style value or exported value.
+ let _output = extract_with_source_policy(
+ "/app.tsx",
+ &code,
+ ExtractOption::default(),
+ false,
+ Some(&resolver),
+ None,
+ &[".mdx".to_string()],
+ );
+ // Then default-render opacity cannot suppress that source-preparation boundary.
+ assert!(reads.borrow().iter().any(|source| source == "./doc.mdx"));
+}
+
+#[test]
+#[serial]
+fn opaque_mdx_policy_preserves_an_ordinary_default_barrel_and_prop_free_primitive() {
+ // Given ordinary JS forwarding a Devup default and an MDX default reexport.
+ let _state = crate::test_state::TestStateGuard::new();
+ let reads = RefCell::new(Vec::new());
+ let resolver = |source: &str, _: &str| {
+ reads.borrow_mut().push(source.to_string());
+ let code = match source {
+ "./ui.js" => "export {Box as default} from '@devup-ui/react';",
+ "./docs.js" => "export {default} from './doc.mdx';",
+ _ => return None,
+ };
+ Some(ModuleResolution::Resolved(ResolvedModule {
+ path: source.to_string(),
+ code: code.to_string(),
+ source_type: None,
+ }))
+ };
+ // When both bindings are used as prop-free JSX components.
+ let Ok(output) = extract_with_source_policy(
+ "/app.tsx",
+ "import Widget from './ui.js'; import Doc from './docs.js'; export const view=;",
+ ExtractOption::default(),
+ false,
+ Some(&resolver),
+ None,
+ &[".mdx".to_string()],
+ ) else {
+ panic!("ordinary default forwarding extracts");
+ };
+ // Then the real primitive compiles while the forwarded certified default stays runtime.
+ assert!(output.code.contains(";"),
+ ExtractOption::default(),
+ false,
+ Some(&resolver),
+ None,
+ &[".mdx".to_string()],
+ ) else {
+ panic!("ordinary JavaScript forwarding extracts");
+ };
+ // Then the forwarding path still compiles to a native element, never a placeholder.
+ assert!(output.code.contains(" impl Fn(&str, &str) -> Option + use<> {
+ fn resolver(&self) -> impl Fn(&str, &str) -> Option + use<> {
let root = self.root.clone();
move |specifier, importer| {
let base = if specifier.starts_with('.') {
@@ -48,9 +48,12 @@ impl Project {
candidates
.into_iter()
.find(|candidate| candidate.is_file())
- .map(|path| ResolvedModule {
- code: fs::read_to_string(&path).unwrap(),
- path: path.to_string_lossy().replace('\\', "/"),
+ .map(|path| {
+ ModuleResolution::Resolved(ResolvedModule {
+ code: fs::read_to_string(&path).unwrap(),
+ path: path.to_string_lossy().replace('\\', "/"),
+ source_type: None,
+ })
})
}
}
@@ -1070,3 +1073,20 @@ fn aliases_that_are_not_package_exports_stay_declarations() {
assert!(code.contains("N1"), "{code}");
assert!(project.error("ui.tsx").contains("ui.tsx:3:"));
}
+
+#[test]
+fn unsupported_child_grammar_does_not_admit_barrel_exports() {
+ let module = ResolvedModule {
+ path: "/src/ui.data".to_string(),
+ code: "export { Box } from '@devup-ui/react'".to_string(),
+ source_type: None,
+ };
+
+ let exports = super::analyze(&module, "@devup-ui/react");
+
+ assert_eq!(exports.path, module.path);
+ assert_eq!(exports.named.len(), 0);
+ assert_eq!(exports.stars, Vec::::new());
+ assert!(exports.mentions_package);
+ assert!(!exports.trivial);
+}
diff --git a/libs/extractor/src/barrel_pipeline_tests.rs b/libs/extractor/src/barrel_pipeline_tests.rs
index 7293f7934..6c82f4499 100644
--- a/libs/extractor/src/barrel_pipeline_tests.rs
+++ b/libs/extractor/src/barrel_pipeline_tests.rs
@@ -1,15 +1,80 @@
use crate::dead_properties_test_utils::{failure, position};
-use crate::{ExtractOption, ImportAlias, ResolvedModule, extract_with_modules};
+use crate::{ExtractOption, ImportAlias, ModuleResolution, ResolvedModule, extract_with_modules};
use css::{class_map::reset_class_map, file_map::reset_file_map};
use rstest::rstest;
use serial_test::serial;
-fn resolver(specifier: &str, _: &str) -> Option {
+#[test]
+#[serial]
+fn follows_barrel_when_root_and_child_have_explicit_compiled_languages()
+-> Result<(), Box> {
+ // Given: JSX precedes the re-export in a custom-extension compiled child.
+ let _state = crate::test_state::TestStateGuard::new();
+ let resolver = |_: &str, _: &str| {
+ Some(ModuleResolution::Resolved(ResolvedModule {
+ path: "/src/ui.mdown".to_string(),
+ code: "export const before = ; export { Box } from '@devup-ui/react';"
+ .to_string(),
+ source_type: Some(crate::ExtractSourceType::CompiledMdx),
+ }))
+ };
+ // When: the root also keeps its real custom filename.
+ let output = crate::extract_with_source_type(
+ "/src/app.mdown",
+ "import * as UI from './ui'; export const before = ; export const a = ;",
+ ExtractOption::default(),
+ true,
+ Some(&resolver),
+ Some(crate::ExtractSourceType::CompiledMdx),
+ )?;
+ // Then: the barrel use compiles and the map/dependency retain real identities.
+ assert!(!output.code.contains(" Result<(), Box> {
+ // Given: an explicitly ignored re-export alongside a genuine Devup export.
+ let _state = crate::test_state::TestStateGuard::new();
+ let resolver = |specifier: &str, _: &str| match specifier {
+ "./ui" => Some(ModuleResolution::Resolved(ResolvedModule {
+ path: "/src/ui.ts".to_string(),
+ code: "export { Box } from '@devup-ui/react'; export { missing } from './ignored';"
+ .to_string(),
+ source_type: None,
+ })),
+ "./ignored" => Some(ModuleResolution::Ignored),
+ _ => None,
+ };
+ // When: both names are imported but only Box is a styling API.
+ let output = extract_with_modules(
+ "/src/app.tsx",
+ "import { Box, missing } from './ui'; export const a = ; export const b = missing;",
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ // Then: ignore is not an unreadable-module fault or a watched file.
+ assert!(!output.code.contains(" Option {
match specifier {
- "./ui" => Some(ResolvedModule {
+ "./ui" => Some(ModuleResolution::Resolved(ResolvedModule {
path: "/src/ui.ts".to_string(),
code: "export { css, Box } from '@devup-ui/react';".to_string(),
- }),
+ source_type: None,
+ })),
_ => None,
}
}
diff --git a/libs/extractor/src/build_time_values.rs b/libs/extractor/src/build_time_values.rs
index d72f62548..6b92ca0da 100644
--- a/libs/extractor/src/build_time_values.rs
+++ b/libs/extractor/src/build_time_values.rs
@@ -65,9 +65,10 @@ pub(crate) fn has_build_time_values(
filename,
&option.package,
&option.import_aliases,
+ crate::parser_source_type(filename).unwrap_or_default(),
);
let allocator = Allocator::default();
- let Some(mut program) = parse(&allocator, filename, &aliased.code) else {
+ let Some(mut program) = parse(&allocator, filename, &aliased.code, None) else {
return false;
};
let inlined = crate::imported_constants::inline_constants(
@@ -135,8 +136,13 @@ const UNCERTAIN_MEMBERS: [&str; 9] = [
"toString",
];
-fn parse<'a>(allocator: &'a Allocator, filename: &str, code: &'a str) -> Option> {
- let source_type = crate::parsing::source_type(filename).ok()?;
+fn parse<'a>(
+ allocator: &'a Allocator,
+ filename: &str,
+ code: &'a str,
+ mode: Option,
+) -> Option> {
+ let source_type = crate::source_type::parser_type(filename, mode).ok()?;
let parsed = Parser::new(allocator, code, source_type).parse();
(!parsed.fatal_error).then_some(parsed.program)
}
@@ -928,12 +934,13 @@ pub(crate) fn evaluate(
option: &ExtractOption,
resolver: Option<&ModuleResolver>,
unknown: &crate::imported_constants::Unknown,
+ mode: Option,
) -> Option<(
String,
Vec,
BTreeSet,
)> {
- let (mut values, dependencies) = compute(code, filename, option, resolver, unknown)?;
+ let (mut values, dependencies) = compute(code, filename, option, resolver, unknown, mode)?;
values.sort_unstable_by_key(|(span, _)| span.start);
let mut result = String::with_capacity(code.len());
let mut edits = Vec::with_capacity(values.len());
@@ -980,13 +987,14 @@ fn compute(
option: &ExtractOption,
resolver: Option<&ModuleResolver>,
unknown: &crate::imported_constants::Unknown,
+ mode: Option,
) -> Option<(Vec, BTreeSet)> {
use std::fmt::Write;
use boa_engine::{Context, JsObject, Source};
let allocator = Allocator::default();
- let program = parse(&allocator, filename, code)?;
+ let program = parse(&allocator, filename, code, mode)?;
let is_style = |source: &str| {
source.starts_with(option.package.as_str()) || option.import_aliases.contains_key(source)
};
@@ -1071,7 +1079,8 @@ fn compute(
.collect();
let _ = writeln!(module, "[{}];", names.join(", "));
- let script = crate::vanilla_extract::strip_typescript(&module, filename);
+ let script =
+ crate::vanilla_extract::strip_typescript_with_type(&module, filename, mode).ok()?;
let mut context = Context::default();
context
.runtime_limits_mut()
diff --git a/libs/extractor/src/class_names_binding_tests.rs b/libs/extractor/src/class_names_binding_tests.rs
index dfaa3ff86..f4f8dbff4 100644
--- a/libs/extractor/src/class_names_binding_tests.rs
+++ b/libs/extractor/src/class_names_binding_tests.rs
@@ -30,9 +30,12 @@ fn compile(code: &str) -> ExtractOutput {
},
false,
&|specifier, _| {
- (specifier == "./data").then(|| ResolvedModule {
- path: "data.ts".to_string(),
- code: "export const data = { padding: 7 }; export const space = 3;".to_string(),
+ (specifier == "./data").then(|| {
+ crate::ModuleResolution::Resolved(ResolvedModule {
+ path: "data.ts".to_string(),
+ code: "export const data = { padding: 7 }; export const space = 3;".to_string(),
+ source_type: None,
+ })
})
},
)
diff --git a/libs/extractor/src/class_selection_support.rs b/libs/extractor/src/class_selection_support.rs
index 61a0a9855..478b192b9 100644
--- a/libs/extractor/src/class_selection_support.rs
+++ b/libs/extractor/src/class_selection_support.rs
@@ -23,9 +23,12 @@ pub fn compile(files: &[(&str, &str)], option: ExtractOption) -> Modules {
sources
.iter()
.find(|(name, _)| *name == path)
- .map(|(name, code)| ResolvedModule {
- path: name.clone(),
- code: code.clone(),
+ .map(|(name, code)| {
+ crate::ModuleResolution::Resolved(ResolvedModule {
+ path: name.clone(),
+ code: code.clone(),
+ source_type: None,
+ })
})
};
files
@@ -78,6 +81,7 @@ pub fn observe(outputs: &Modules, observer: &str, globals: &str) -> serde_json::
map: output.map.clone(),
css_file: output.css_file.clone(),
dependencies: output.dependencies.clone(),
+ deferred_defaults: output.deferred_defaults.clone(),
},
)
}));
diff --git a/libs/extractor/src/compiled_guard/callable.rs b/libs/extractor/src/compiled_guard/callable.rs
new file mode 100644
index 000000000..c6cbec956
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/callable.rs
@@ -0,0 +1,132 @@
+use oxc_allocator::{Address, UnstableAddress};
+use oxc_ast::ast::{
+ BindingPattern, Declaration, ExportDefaultDeclarationKind, Expression, Function, Program,
+ Statement, VariableDeclaration, VariableDeclarationKind,
+};
+use oxc_ast_visit::Visit;
+use rustc_hash::{FxHashMap, FxHashSet};
+
+use super::{traversal::Collector, writes::Writes};
+
+#[derive(Clone, PartialEq, Eq)]
+pub(super) enum Proof {
+ Declaration(String, Address),
+ Function,
+ Alias(String),
+ Other,
+}
+
+impl Proof {
+ pub fn expression(node: &Expression<'_>) -> Self {
+ match node {
+ Expression::FunctionExpression(_) | Expression::ArrowFunctionExpression(_) => {
+ Self::Function
+ }
+ Expression::Identifier(id) => Self::Alias(id.name.to_string()),
+ _ => Self::Other,
+ }
+ }
+
+ fn function(node: &Function<'_>) -> Self {
+ Self::Declaration(
+ node.id
+ .as_ref()
+ .map_or("", |id| id.name.as_str())
+ .to_owned(),
+ node.unstable_address(),
+ )
+ }
+
+ pub fn default_declaration(node: &ExportDefaultDeclarationKind<'_>) -> Self {
+ match node {
+ ExportDefaultDeclarationKind::FunctionDeclaration(function) => Self::function(function),
+ _ => node.as_expression().map_or(Self::Other, Self::expression),
+ }
+ }
+}
+
+#[derive(Default)]
+pub(super) struct Callables {
+ pub locals: FxHashMap,
+ pub default: Option,
+}
+
+impl Callables {
+ pub fn prepare(&mut self, program: &Program<'_>) {
+ for statement in &program.body {
+ match statement {
+ Statement::FunctionDeclaration(node) => self.function(node),
+ Statement::VariableDeclaration(node) => self.variables(node),
+ Statement::ExportDeclaration(node) => match &node.declaration {
+ Declaration::FunctionDeclaration(node) => self.function(node),
+ Declaration::VariableDeclaration(node) => self.variables(node),
+ _ => {}
+ },
+ Statement::ExportDefaultDeclaration(node) => {
+ if let ExportDefaultDeclarationKind::FunctionDeclaration(function) =
+ &node.declaration
+ {
+ self.function(function);
+ }
+ }
+ _ => {}
+ }
+ }
+ }
+
+ fn function(&mut self, node: &Function<'_>) {
+ let proof = Proof::function(node);
+ let name = node.id.as_ref().map_or("", |id| id.name.as_str());
+ self.locals.insert(name.to_owned(), proof);
+ }
+
+ fn variables(&mut self, node: &VariableDeclaration<'_>) {
+ if node.kind != VariableDeclarationKind::Const {
+ return;
+ }
+ for declaration in &node.declarations {
+ if let (BindingPattern::BindingIdentifier(id), Some(init)) =
+ (&declaration.id, &declaration.init)
+ {
+ self.locals
+ .insert(id.name.to_string(), Proof::expression(init));
+ }
+ }
+ }
+
+ fn callable(&self) -> bool {
+ let mut current = self.default.as_ref();
+ let mut seen = FxHashSet::default();
+ while let Some(proof) = current {
+ match proof {
+ Proof::Declaration(name, _) => {
+ return name.is_empty() || self.locals.get(name) == Some(proof);
+ }
+ Proof::Function => return true,
+ Proof::Alias(name) => {
+ if !seen.insert(name) {
+ return false;
+ }
+ current = self.locals.get(name);
+ }
+ Proof::Other => return false,
+ }
+ }
+ false
+ }
+}
+
+impl Collector {
+ pub fn finish(&mut self, program: &Program<'_>) {
+ if let Some(callables) = &mut self.callables {
+ Writes {
+ scopes: &self.scopes,
+ callables,
+ }
+ .visit_program(program);
+ if let Some(observation) = &mut self.facts.observation {
+ observation.default_callable = callables.callable();
+ }
+ }
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/callable_tests.rs b/libs/extractor/src/compiled_guard/callable_tests.rs
new file mode 100644
index 000000000..5cd6579f7
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/callable_tests.rs
@@ -0,0 +1,190 @@
+use std::{error::Error, fmt::Write};
+
+use rstest::rstest;
+use serde_json::json;
+
+use super::tests::facts;
+
+const OBJECT_ASSIGNMENT_SOURCE: &str =
+ "function Content(){}; ({value:Content}={value:0}); export default Content;";
+const FOR_IN_SOURCE: &str =
+ "function Content(){}; for(Content in {x:0}){}; export default Content;";
+const LOOP_PATTERN_SOURCE: &str =
+ "function Content(){}; for({value:Content} of [{value:0}]){}; export default Content;";
+
+#[rstest]
+#[case("function Content(){}; export default Content;", true)]
+#[case("export default function Content(){};", true)]
+#[case("export default function(){};", true)]
+#[case("export default ()=>0;", true)]
+#[case("const Content=(()=>0); export default Content;", true)]
+#[case("const Content=function Named(){}; export default Content;", true)]
+#[case("export const Content=()=>0; export {Content as default};", true)]
+#[case("export function Content(){}; export {Content as default};", true)]
+#[case(
+ "function Content(){}; const A=Content; const B=A; export default B;",
+ true
+)]
+#[case(
+ "function Content(){}; function change(Content){Content=0;} export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; {let Content; Content=0;} export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; try{}catch(Content){Content=0;} export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; for(let Content of [0]){Content++;} export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; function change(){var Content; Content=0;} export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; const change=function Content(){Content=0;}; export default Content;",
+ true
+)]
+#[case("function Content(){}; Content.value=0; export default Content;", true)]
+#[case(
+ "function Content(){}; [Content.value]=[0]; export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; let x; ({[Content]:x}={}); export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; function change(){function Content(){}; Content=0;} export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; function change(Content){eval('Content=0');} export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; {let Content=1; eval('Content=0');} export default Content;",
+ true
+)]
+#[case("const Content=()=>0; eval('void 0'); export default Content;", true)]
+#[case(
+ "function Content(){}; eval?.('void 0'); export default Content;",
+ true
+)]
+#[case(
+ "function Content(){}; (0,eval)('void 0'); export default Content;",
+ true
+)]
+#[case("function Content(){}; Content=0; export default Content;", false)]
+#[case(
+ "function Content(){}; Content=0; const A=Content; const B=A; export default B;",
+ false
+)]
+#[case("export default function Content(){}; Content=0;", false)]
+#[case("function Content(){}; Content=0; export {Content as default};", false)]
+#[case(OBJECT_ASSIGNMENT_SOURCE, false)]
+#[case("function Content(){}; [Content]=[0]; export default Content;", false)]
+#[case(
+ "function Content(){}; ({value:[Content=0]}={value:[]}); export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; [...Content]=[]; export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; ({...Content}={}); export default Content;",
+ false
+)]
+#[case("function Content(){}; Content++; export default Content;", false)]
+#[case(
+ "function Content(){}; for(Content of [0]){}; export default Content;",
+ false
+)]
+#[case(FOR_IN_SOURCE, false)]
+#[case("function Content(){}; Content+=0; export default Content;", false)]
+#[case(LOOP_PATTERN_SOURCE, false)]
+#[case(
+ "function Content(){}; function change(){Content=0;} export default Content;",
+ false
+)]
+#[case("function Content(){Content=0;} export default Content;", false)]
+#[case(
+ "function Content(){}; function change(x=(Content=0)){} export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; let x; ({[Content=0]:x}={}); export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; const holder={}; [holder[Content=0]]=[1]; export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; const holder={}; ({x:holder[Content=0]}={x:1}); export default Content;",
+ false
+)]
+#[case("function Content(){}; export {Content as default}; Content=0;", false)]
+#[case(
+ "function Content(){}; eval('Content=0'); export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; const code='Content=0'; eval(code); export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; eval('Content=0'); const A=Content; const B=A; export default B;",
+ false
+)]
+#[case("export default function Content(){}; eval('Content=0');", false)]
+#[case(
+ "function Content(){}; function change(){eval('Content=0');} export default Content;",
+ false
+)]
+#[case(
+ "function Content(){eval('Content=0');} export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; function change(Content){eval('Content=0');} eval('Content=0'); export default Content;",
+ false
+)]
+#[case("function Content(){};", false)]
+#[case("export default 0;", false)]
+#[case("export default missing;", false)]
+#[case("const A=B; const B=A; export default A;", false)]
+#[case("export {default} from 'content';", false)]
+#[case("let Content=()=>0; export default Content;", false)]
+#[case("export default class Content{};", false)]
+fn resolves_callable_when_local_provenance_is_intact(
+ #[case] code: &str,
+ #[case] callable: bool,
+) -> Result<(), Box> {
+ // Given: a local default proof with lexical writes or shadows.
+ // When: observation resolves aliases after collecting all writes.
+ let result = facts(code, true)?;
+ // Then: only intact local callable provenance is certified.
+ assert_eq!(result["observation"]["defaultCallable"], json!(callable));
+ Ok(())
+}
+
+#[test]
+fn resolves_iteratively_when_alias_chain_is_long() -> Result<(), Box> {
+ // Given: a long acyclic chain of local const aliases.
+ let mut aliases = String::new();
+ for index in 0..5000 {
+ write!(aliases, "const A{}=A{index};", index + 1)?;
+ }
+ let code = format!("function Content(){{}} const A0=Content;{aliases}export default A5000;");
+ // When: default proof follows the aliases.
+ let result = facts(&code, true)?;
+ // Then: the terminal function is reached without recursive alias evaluation.
+ assert_eq!(result["observation"]["defaultCallable"], json!(true));
+ Ok(())
+}
diff --git a/libs/extractor/src/compiled_guard/coverage_helper_tests.rs b/libs/extractor/src/compiled_guard/coverage_helper_tests.rs
new file mode 100644
index 000000000..3aa963314
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/coverage_helper_tests.rs
@@ -0,0 +1,177 @@
+use std::error::Error;
+
+use oxc_allocator::Allocator;
+use oxc_ast::ast::{PropertyDefinition, Statement};
+use oxc_ast_visit::Visit;
+use oxc_parser::Parser;
+use oxc_span::SourceType;
+use rstest::rstest;
+use serde_json::{Value, json};
+
+use super::{
+ compiled_guard_facts_internal, diagnostics,
+ origins::{export_name, local_name, property_name},
+ scopes::Scopes,
+ text::Text,
+ traversal::Collector,
+ wire::{Facts, Origin, Positions},
+};
+
+#[rstest]
+#[case("a\r\n😀x", (2, 4))]
+#[case("a\rb\nc\u{2028}d\u{2029}😀", (5, 3))]
+#[case("a\r\n\n", (3, 1))]
+fn location_when_line_endings_and_astral_characters_are_mixed(
+ #[case] code: &str,
+ #[case] expected: (usize, usize),
+) -> Result<(), Box> {
+ // Given: byte positions at the end of text with JS line terminators.
+ let offset = u32::try_from(code.len())?;
+ // When: diagnostics convert bytes to line and UTF-16 column.
+ let result = diagnostics::location(code, offset);
+ // Then: CRLF counts once and astral characters count two columns.
+ assert_eq!(result, expected);
+ Ok(())
+}
+
+#[rstest]
+#[case("\r\n")]
+#[case("\r")]
+#[case("\n")]
+#[case("\u{2028}")]
+#[case("\u{2029}")]
+fn diagnostic_when_invalid_js_follows_a_line_terminator(#[case] ending: &str) {
+ // Given: valid astral text followed by a syntactically invalid declaration.
+ let code = format!("let emoji='😀';{ending}const value = ;");
+ // When: the public facts API rejects the actual parser error.
+ let result = compiled_guard_facts_internal(&code, false);
+ // Then: the diagnostic locates the bad token on the second line.
+ assert!(matches!(result, Err(error) if error.to_string().starts_with("compiled output:2:15:")));
+}
+
+#[test]
+fn property_names_when_parser_produces_private_and_computed_keys() {
+ #[derive(Default)]
+ struct Keys(Vec>);
+ impl<'a> Visit<'a> for Keys {
+ fn visit_property_definition(&mut self, node: &PropertyDefinition<'a>) {
+ self.0.push(property_name(&node.key, node.computed));
+ }
+ }
+ // Given: real class field keys, including a dynamic computed key.
+ let allocator = Allocator::default();
+ let parsed = Parser::new(
+ &allocator,
+ "class C{#secret; plain; ['literal']; [dynamic];}",
+ SourceType::jsx(),
+ )
+ .parse();
+ assert_eq!(parsed.diagnostics.errors().count(), 0);
+ let mut keys = Keys::default();
+ // When: the naming helper reads actual key kinds and computed flags.
+ keys.visit_program(&parsed.program);
+ // Then: private names retain their name and dynamic keys remain unknown.
+ assert_eq!(
+ keys.0,
+ vec![
+ Some(Text::from("secret")),
+ Some(Text::from("plain")),
+ Some(Text::from("literal")),
+ None
+ ]
+ );
+}
+
+#[test]
+fn module_names_when_local_and_exported_ast_variants_differ() -> Result<(), Box> {
+ // Given: a local export with an IdentifierReference and IdentifierName.
+ let allocator = Allocator::default();
+ let parsed = Parser::new(
+ &allocator,
+ "const css=0; export {css as renamed};",
+ SourceType::jsx(),
+ )
+ .parse();
+ assert_eq!(parsed.diagnostics.errors().count(), 0);
+ let Statement::ExportNamedDeclaration(node) = &parsed.program.body[1] else {
+ return Err("named export node".into());
+ };
+ let specifier = &node.specifiers[0];
+ // When: the helpers read both parser-provided name variants.
+ let result = (
+ export_name(&specifier.local),
+ local_name(&specifier.exported),
+ );
+ // Then: names agree without treating the exported alias as the local binding.
+ assert_eq!(result, (Text::from("css"), Some("renamed")));
+ Ok(())
+}
+
+#[test]
+fn local_name_when_forwarded_export_uses_a_string_literal() -> Result<(), Box> {
+ // Given: a valid string-named forwarding export, not a local binding.
+ let allocator = Allocator::default();
+ let parsed = Parser::new(
+ &allocator,
+ "export {'css' as renamed} from 'ui';",
+ SourceType::jsx(),
+ )
+ .parse();
+ assert_eq!(parsed.diagnostics.errors().count(), 0);
+ let Statement::ExportFromDeclaration(node) = &parsed.program.body[0] else {
+ return Err("forwarded export node".into());
+ };
+ // When: the local-name helper sees the real string variant.
+ let result = local_name(&node.specifiers[0].local);
+ // Then: a string export name cannot masquerade as a lexical binding.
+ assert_eq!(result, None);
+ Ok(())
+}
+
+#[rstest]
+#[case("export interface Shape{}", json!([]))]
+#[case("export class Shape{}", json!([["Shape", null]]))]
+fn declared_exports_when_parser_declarations_are_type_only_or_classes(
+ #[case] code: &str,
+ #[case] expected: Value,
+) -> Result<(), Box> {
+ // Given: parser-created declarations for the helper's Declaration input type.
+ let allocator = Allocator::default();
+ let parsed = Parser::new(&allocator, code, SourceType::tsx()).parse();
+ assert_eq!(parsed.diagnostics.errors().count(), 0);
+ let Statement::ExportDeclaration(node) = &parsed.program.body[0] else {
+ return Err("export declaration node".into());
+ };
+ let mut collector = Collector::new(Scopes::build(&parsed.program), Positions::new(code), false);
+ // When: the internal declaration helper collects runtime export names.
+ collector.declared_export(&node.declaration);
+ // Then: class declarations are named and type-only declarations add nothing.
+ let result: Value = serde_json::from_str(&collector.facts.json())?;
+ assert_eq!(result["exports"], expected);
+ Ok(())
+}
+
+#[test]
+fn wire_export_when_existing_name_is_replaced_after_another_insertion() -> Result<(), Box>
+{
+ // Given: the ordered wire accumulator with two distinct exported names.
+ let mut facts = Facts::new(false);
+ facts.export(Text::from("first"), None);
+ facts.export(Text::from("second"), None);
+ let origin = Origin {
+ request: Text::from("ui"),
+ ids: vec![Text::from("css")],
+ require: true,
+ };
+ // When: a later fact supplies provenance for an already inserted name.
+ facts.export(Text::from("first"), Some(origin));
+ // Then: the origin changes without duplication or moving its original slot.
+ let result: Value = serde_json::from_str(&facts.json())?;
+ assert_eq!(
+ result["exports"],
+ json!([
+ ["first", {"request":"ui","ids":["css"],"kind":"require-call"}], ["second", null]
+ ])
+ );
+ Ok(())
+}
diff --git a/libs/extractor/src/compiled_guard/coverage_reference_tests.rs b/libs/extractor/src/compiled_guard/coverage_reference_tests.rs
new file mode 100644
index 000000000..0dc53761f
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/coverage_reference_tests.rs
@@ -0,0 +1,181 @@
+use std::error::Error;
+
+use rstest::rstest;
+use serde_json::{Value, json};
+
+use super::tests::facts;
+
+const DESTRUCTURED_ALIAS_SOURCE: &str = "let renamed; ({css:renamed}=DU);";
+
+#[rstest]
+#[case("const Alias=DU['css']; Alias.child;", json!([["css"], ["css", "child"]]))]
+#[case("class C{#css; m(){DU.#css.child;}}", json!([["css", "child"]]))]
+#[case("class C{#css; m(){const Alias=DU.#css; Alias.child;}}", json!([["css"], ["css", "child"]]))]
+#[case("let css; ({css}=DU);", json!([["css"]]))]
+#[case(DESTRUCTURED_ALIAS_SOURCE, json!([["css"]]))]
+fn paths_when_members_are_computed_private_or_destructured(
+ #[case] body: &str,
+ #[case] expected: Value,
+) -> Result<(), Box> {
+ // Given: a definite namespace and a member or destructured read of it.
+ let code = format!("import * as DU from 'ui'; {body}");
+ // When: parser-created member nodes propagate their actual origin.
+ let result = facts(&code, false)?;
+ // Then: each outer read retains the complete path without inner duplicates.
+ let references = result["references"].as_array().ok_or("reference array")?;
+ let paths: Vec<_> = references
+ .iter()
+ .map(|value| value["ids"].clone())
+ .collect();
+ assert_eq!(json!(paths), expected);
+ assert!(references.iter().all(|value| value["request"] == "ui"));
+ Ok(())
+}
+
+#[rstest]
+#[case("true")]
+#[case("null")]
+#[case("1")]
+#[case("1n")]
+#[case("/key/")]
+fn empty_literal_name_when_computed_key_is_not_a_string(
+ #[case] key: &str,
+) -> Result<(), Box> {
+ // Given: the established non-string literal naming policy.
+ let code = format!("import * as DU from 'ui'; DU[{key}];");
+ // When: the real member visitor resolves a non-string literal key.
+ let result = facts(&code, false)?;
+ // Then: the wire keeps an empty path segment, not a coerced JS value.
+ assert_eq!(
+ result["references"],
+ json!([{"request":"ui","ids":[""],"pos":26}])
+ );
+ Ok(())
+}
+
+#[rstest]
+#[case("get().css;")]
+#[case("({get}).get().css;")]
+#[case("require(get).css;")]
+#[case("class C{#css; m(){get().#css;}}")]
+fn imported_reads_when_call_cannot_be_a_require_origin(
+ #[case] body: &str,
+) -> Result<(), Box> {
+ // Given: a call with an ordinary, member or nonliteral require callee shape.
+ let code = format!("import {{get}} from 'ui'; {body}");
+ // When: rejecting the origin causes traversal of the real call contents.
+ let result = facts(&code, false)?;
+ // Then: the imported argument/callee is retained, but no css origin is invented.
+ let references = result["references"].as_array().ok_or("reference array")?;
+ assert_eq!(references.len(), 1);
+ assert_eq!(references[0]["request"], json!("ui"));
+ assert_eq!(references[0]["ids"], json!(["get"]));
+ Ok(())
+}
+
+#[rstest]
+#[case("const obj={[css()]:0};")]
+#[case("class C{[css()](){}}")]
+#[case("let local; ({local=css}={});")]
+fn references_when_keys_and_shorthand_defaults_are_expressions(
+ #[case] body: &str,
+) -> Result<(), Box> {
+ // Given: a computed non-Identifier key or a shorthand assignment default.
+ let code = format!("import {{css}} from 'ui'; {body}");
+ // When: the specialized key and pattern visitors walk expression reads.
+ let result = facts(&code, false)?;
+ // Then: the expression contributes exactly the imported css read.
+ let references = result["references"].as_array().ok_or("reference array")?;
+ assert_eq!(references.len(), 1);
+ assert_eq!(references[0]["ids"], json!(["css"]));
+ Ok(())
+}
+
+#[rstest]
+#[case("meta", "import.meta;")]
+#[case("meta", "function f(){import.meta;}")]
+#[case("meta", "{let meta; import.meta;}")]
+#[case("meta", "function f(meta){import.meta;}")]
+#[case("target", "function f(){new.target;}")]
+#[case("target", "function f(target){new.target;}")]
+fn references_when_meta_properties_match_imported_local_names(
+ #[case] name: &str,
+ #[case] body: &str,
+ #[values(false, true)] after: bool,
+) -> Result<(), Box> {
+ // Given: same-named css imports before or after shadowed/unshadowed meta properties.
+ let declaration = format!("import {{css as {name}}} from 'ui';");
+ let code = if after {
+ format!("{body}{declaration}")
+ } else {
+ format!("{declaration}{body}")
+ };
+ // When: the real parser collects facts in both observation modes.
+ let results = [facts(&code, false)?, facts(&code, true)?];
+ // Then: neither keyword suffix is a lexical reference to the imported binding.
+ for result in results {
+ assert_eq!(result["references"], json!([]));
+ }
+ Ok(())
+}
+
+#[rstest]
+#[case("meta", "import.meta; void meta;")]
+#[case("meta", "import.meta[meta];")]
+#[case("target", "function f(){new.target; void target;}")]
+#[case("target", "function f(){new.target[target];}")]
+fn references_when_meta_properties_have_real_binding_reads(
+ #[case] name: &str,
+ #[case] body: &str,
+) -> Result<(), Box> {
+ // Given: an actual identifier or computed expression read next to a meta property.
+ let code = format!("import {{css as {name}}} from 'ui';{body}");
+ // When: the real parser collects reference facts.
+ let result = facts(&code, false)?;
+ // Then: only the actual binding read carries css provenance and its own position.
+ assert_eq!(
+ result["references"],
+ json!([{
+ "request":"ui", "ids":["css"], "pos":code.rfind(name).ok_or("binding read")?
+ }])
+ );
+ Ok(())
+}
+
+#[rstest]
+#[case("export class Content{}; export default Content;", false)]
+#[case("function Content(){}; ({Content}={}); export default Content;", false)]
+#[case(
+ "function Content(){}; ({Content=0}={}); export default Content;",
+ false
+)]
+#[case(
+ "function Content(){}; function f(Content){({Content}={});} export default Content;",
+ true
+)]
+fn callable_when_class_exports_and_shorthand_writes_have_real_provenance(
+ #[case] code: &str,
+ #[case] expected: bool,
+) -> Result<(), Box> {
+ // Given: class declarations or object shorthand writes to root and shadow bindings.
+ // When: observation prepares exports and then collects writes.
+ let result = facts(code, true)?;
+ // Then: neither a class nor an overwritten root function is certified callable.
+ assert_eq!(result["observation"]["defaultCallable"], json!(expected));
+ Ok(())
+}
+
+#[test]
+fn wire_strings_when_requests_and_exports_contain_json_escapes() -> Result<(), Box> {
+ // Given: JavaScript literals containing quotes, slashes and control characters.
+ let code = r#"import { 'a"b\\c\n\t\0' as local } from 'u"i\\\r'; export {local as 'out"\\\b'}; local;"#;
+ // When: literal UTF-16 data crosses the real facts JSON encoder.
+ let result = facts(code, false)?;
+ // Then: decoding the wire recovers the original literal values exactly.
+ assert_eq!(
+ result["exports"],
+ json!([["out\"\\\u{8}", {"request":"u\"i\\\r","ids":["a\"b\\c\n\t\0"]}]])
+ );
+ assert_eq!(result["references"][0]["request"], json!("u\"i\\\r"));
+ Ok(())
+}
diff --git a/libs/extractor/src/compiled_guard/coverage_scope_tests.rs b/libs/extractor/src/compiled_guard/coverage_scope_tests.rs
new file mode 100644
index 000000000..23c70f973
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/coverage_scope_tests.rs
@@ -0,0 +1,54 @@
+use std::error::Error;
+
+use rstest::rstest;
+use serde_json::json;
+
+use super::tests::facts;
+
+#[rstest]
+#[case("{var local;} local; css();", 1)]
+#[case("function f(){css(); {var css;}}", 0)]
+#[case("function f(){css(); {let css;}}", 1)]
+#[case("function f(){css(); {const css=0;}}", 1)]
+#[case("function f(){function g(){if(0){var css;} css();} css();}", 1)]
+#[case("function f(){if(0){var css;} function g(){css();}}", 0)]
+#[case("function f(...css){css();} css();", 1)]
+#[case("const f=(...css)=>css(); css();", 1)]
+#[case("function f(...[css]){css();} css();", 1)]
+fn references_when_var_hoists_but_lexical_and_parameter_bindings_stay_local(
+ #[case] body: &str,
+ #[case] count: usize,
+) -> Result<(), Box> {
+ // Given: imported css and nested declarations, including reads before var.
+ let code = format!("import {{css}} from 'ui'; {body}");
+ // When: the real parser and scope builder collect reference provenance.
+ let result = facts(&code, false)?;
+ // Then: only reads outside the shadow's owning scope retain the import.
+ let references = result["references"].as_array().ok_or("reference array")?;
+ assert_eq!(references.len(), count);
+ for reference in references {
+ assert_eq!(reference["request"], json!("ui"));
+ assert_eq!(reference["ids"], json!(["css"]));
+ }
+ Ok(())
+}
+
+#[rstest]
+#[case("{var Content;} Content=0;", false)]
+#[case("{let Content;} Content=0;", false)]
+#[case("function f(){Content=0; {var Content;}}", true)]
+#[case("function f(){Content=0; {let Content;}}", false)]
+#[case("function f(){function g(){if(0){var Content;} Content=0;}}", true)]
+#[case("function f(...Content){Content=0;}", true)]
+fn callable_when_writes_resolve_to_root_or_function_hoisted_shadow(
+ #[case] body: &str,
+ #[case] callable: bool,
+) -> Result<(), Box> {
+ // Given: a root function and writes in scopes with differing ownership.
+ let code = format!("function Content(){{}} {body} export default Content;");
+ // When: observation invalidates callable proofs using actual scope owners.
+ let result = facts(&code, true)?;
+ // Then: only writes to the root binding invalidate its callable proof.
+ assert_eq!(result["observation"]["defaultCallable"], json!(callable));
+ Ok(())
+}
diff --git a/libs/extractor/src/compiled_guard/diagnostics.rs b/libs/extractor/src/compiled_guard/diagnostics.rs
new file mode 100644
index 000000000..6a4c0656d
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/diagnostics.rs
@@ -0,0 +1,21 @@
+pub(super) fn location(code: &str, offset: u32) -> (usize, usize) {
+ let offset = usize::try_from(offset).unwrap_or(code.len());
+ let mut line = 1;
+ let mut column = 1;
+ let mut carriage_return = false;
+ for (byte, ch) in code.char_indices() {
+ if byte >= offset {
+ break;
+ }
+ match ch {
+ '\n' if carriage_return => {}
+ '\r' | '\n' | '\u{2028}' | '\u{2029}' => {
+ line += 1;
+ column = 1;
+ }
+ _ => column += ch.len_utf16(),
+ }
+ carriage_return = ch == '\r';
+ }
+ (line, column)
+}
diff --git a/libs/extractor/src/compiled_guard/exports.rs b/libs/extractor/src/compiled_guard/exports.rs
new file mode 100644
index 000000000..0d8f2dd3c
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/exports.rs
@@ -0,0 +1,190 @@
+use oxc_allocator::UnstableAddress;
+use oxc_ast::ast::{
+ Declaration, ExportAllDeclaration, ExportDefaultDeclaration, ExportFromDeclaration,
+ ExportNamedDeclaration, ImportDeclarationSpecifier, Program, Statement,
+};
+
+use super::{
+ callable::Proof,
+ origins::{export_name, local_name, origin},
+ scopes::pattern_names,
+ text::Text,
+ traversal::Collector,
+ wire::{Origin, insert_request},
+};
+
+impl Collector {
+ pub fn prepare(&mut self, program: &Program<'_>) {
+ if let Some(callables) = &mut self.callables {
+ callables.prepare(program);
+ }
+ let mut import_only = (self.facts.observation.is_some()
+ && program.directives.is_empty()
+ && !program.body.is_empty())
+ .then(Vec::new);
+ for statement in &program.body {
+ let (source, attributes) = match statement {
+ Statement::ImportDeclaration(node) => {
+ (Some(&node.source), node.with_clause.as_deref())
+ }
+ Statement::ExportFromDeclaration(node) => {
+ (Some(&node.source), node.with_clause.as_deref())
+ }
+ Statement::ExportAllDeclaration(node) => {
+ (Some(&node.source), node.with_clause.as_deref())
+ }
+ _ => (None, None),
+ };
+ let attributed =
+ attributes.is_some_and(|attributes| !attributes.with_entries.is_empty());
+ if let (Some(proof), Some(source)) = (&mut self.facts.observation, source)
+ && attributed
+ {
+ insert_request(&mut proof.unsupported_requests, Text::literal(source));
+ }
+ match statement {
+ Statement::ImportDeclaration(node) => {
+ if node
+ .specifiers
+ .as_ref()
+ .is_none_or(|specifiers| specifiers.is_empty())
+ && !attributed
+ {
+ if let Some(requests) = &mut import_only {
+ insert_request(requests, Text::literal(&node.source));
+ }
+ } else {
+ import_only = None;
+ }
+ for specifier in node.specifiers.iter().flatten() {
+ let (name, ids) = match specifier {
+ ImportDeclarationSpecifier::ImportNamespaceSpecifier(specifier) => {
+ (specifier.local.name.as_str(), Vec::new())
+ }
+ ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => {
+ (specifier.local.name.as_str(), vec![Text::from("default")])
+ }
+ ImportDeclarationSpecifier::ImportSpecifier(specifier) => (
+ specifier.local.name.as_str(),
+ vec![export_name(&specifier.imported)],
+ ),
+ };
+ self.scopes.entries[0].bindings.insert(
+ name.to_owned(),
+ Some(Origin {
+ request: Text::literal(&node.source),
+ ids,
+ require: false,
+ }),
+ );
+ }
+ }
+ _ => import_only = None,
+ }
+ }
+ if let Some(proof) = &mut self.facts.observation {
+ proof.import_only_requests = import_only;
+ }
+ }
+
+ pub fn named_export(&mut self, node: &ExportNamedDeclaration<'_>) {
+ let scope = self.scopes.at(node.unstable_address());
+ for specifier in &node.specifiers {
+ let name = export_name(&specifier.exported);
+ let value =
+ local_name(&specifier.local).and_then(|name| self.scopes.binding(scope, name));
+ if name.is_default()
+ && let Some(callables) = &mut self.callables
+ {
+ callables.default =
+ local_name(&specifier.local).map(|name| Proof::Alias(name.to_owned()));
+ }
+ self.facts.export(name, value);
+ }
+ }
+
+ pub fn forward_export(&mut self, node: &ExportFromDeclaration<'_>) {
+ let scope = self.scopes.at(node.unstable_address());
+ for specifier in &node.specifiers {
+ let name = export_name(&specifier.exported);
+ let request = Text::literal(&node.source);
+ if name.is_default()
+ && let Some(callables) = &mut self.callables
+ {
+ callables.default = if request.is_empty() {
+ local_name(&specifier.local).map(|name| Proof::Alias(name.to_owned()))
+ } else {
+ None
+ };
+ }
+ let value = if request.is_empty() {
+ local_name(&specifier.local).and_then(|name| self.scopes.binding(scope, name))
+ } else {
+ Some(Origin {
+ request,
+ ids: vec![export_name(&specifier.local)],
+ require: false,
+ })
+ };
+ self.facts.export(name, value);
+ }
+ }
+
+ pub fn star_export(&mut self, node: &ExportAllDeclaration<'_>) {
+ let request = Text::literal(&node.source);
+ match node
+ .exported
+ .as_ref()
+ .map(export_name)
+ .filter(|name| !name.is_empty())
+ {
+ Some(name) => self.facts.export(
+ name,
+ Some(Origin {
+ request,
+ ids: Vec::new(),
+ require: false,
+ }),
+ ),
+ None => self.facts.stars.push(request),
+ }
+ }
+
+ pub fn declared_export(&mut self, declaration: &Declaration<'_>) {
+ let names = match declaration {
+ Declaration::VariableDeclaration(node) => node
+ .declarations
+ .iter()
+ .flat_map(|declaration| pattern_names(&declaration.id))
+ .collect(),
+ Declaration::FunctionDeclaration(node) => vec![
+ node.id
+ .as_ref()
+ .map_or("", |id| id.name.as_str())
+ .to_owned(),
+ ],
+ Declaration::ClassDeclaration(node) => vec![
+ node.id
+ .as_ref()
+ .map_or("", |id| id.name.as_str())
+ .to_owned(),
+ ],
+ _ => Vec::new(),
+ };
+ for name in names {
+ self.facts.export(Text::from(name.as_str()), None);
+ }
+ }
+
+ pub fn default_export(&mut self, node: &ExportDefaultDeclaration<'_>) {
+ let scope = self.scopes.at(node.unstable_address());
+ let value = node
+ .declaration
+ .as_expression()
+ .and_then(|node| origin(node, &self.scopes, scope));
+ self.facts.export(Text::from("default"), value);
+ if let Some(callables) = &mut self.callables {
+ callables.default = Some(Proof::default_declaration(&node.declaration));
+ }
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/mod.rs b/libs/extractor/src/compiled_guard/mod.rs
new file mode 100644
index 000000000..a4958071b
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/mod.rs
@@ -0,0 +1,99 @@
+//! Final-JavaScript guard facts collected directly from the Oxc AST.
+
+mod callable;
+#[cfg(test)]
+mod callable_tests;
+#[cfg(test)]
+mod coverage_helper_tests;
+#[cfg(test)]
+mod coverage_reference_tests;
+#[cfg(test)]
+mod coverage_scope_tests;
+mod diagnostics;
+mod exports;
+#[cfg(test)]
+mod observation_tests;
+mod origins;
+mod patterns;
+#[cfg(test)]
+mod reference_tests;
+mod scopes;
+#[cfg(test)]
+mod tests;
+mod text;
+mod traversal;
+mod wire;
+mod writes;
+
+use std::{error::Error, fmt};
+
+use oxc_allocator::Allocator;
+use oxc_ast_visit::Visit;
+use oxc_parser::{ParseOptions, Parser};
+use oxc_span::SourceType;
+
+use scopes::Scopes;
+use traversal::Collector;
+use wire::Positions;
+
+/// Failure to parse final JavaScript.
+#[derive(Debug)]
+pub enum CompiledGuardError {
+ /// Located parser diagnostics in final compiled output.
+ Parse(Vec),
+}
+
+impl fmt::Display for CompiledGuardError {
+ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Parse(errors) => formatter.write_str(&errors.join("\n")),
+ }
+ }
+}
+
+impl Error for CompiledGuardError {}
+
+/// Produce ordered guard facts for final JavaScript, allowing JSX but not TypeScript.
+///
+/// Parentheses follow the current Vite public parser: no wrapper nodes. Positions
+/// on the wire are JavaScript UTF-16 offsets. This never executes source or
+/// accesses extraction/CSS state.
+///
+/// # Errors
+/// Returns located parse diagnostics rather than facts for invalid JavaScript.
+pub fn compiled_guard_facts_internal(
+ code: &str,
+ observe: bool,
+) -> Result {
+ let allocator = Allocator::default();
+ let parsed = Parser::new(&allocator, code, SourceType::jsx())
+ .with_options(ParseOptions {
+ preserve_parens: false,
+ ..ParseOptions::default()
+ })
+ .parse();
+ let positions = Positions::new(code);
+ let errors: Vec<_> = parsed
+ .diagnostics
+ .errors()
+ .map(|error| {
+ let offset = error
+ .labels
+ .iter()
+ .find(|label| label.primary())
+ .or_else(|| error.labels.first())
+ .map_or(0, oxc_span::LabeledSpan::offset);
+ let (line, column) = diagnostics::location(code, offset);
+ format!("compiled output:{line}:{column}: {error}")
+ })
+ .collect();
+ if !errors.is_empty() {
+ return Err(CompiledGuardError::Parse(errors));
+ }
+ let scopes = Scopes::build(&parsed.program);
+ let mut collector = Collector::new(scopes, positions, observe);
+ collector.prepare(&parsed.program);
+ collector.visit_program(&parsed.program);
+ collector.finish(&parsed.program);
+ Ok(collector.facts.json())
+}
diff --git a/libs/extractor/src/compiled_guard/observation_tests.rs b/libs/extractor/src/compiled_guard/observation_tests.rs
new file mode 100644
index 000000000..6dcf8885f
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/observation_tests.rs
@@ -0,0 +1,69 @@
+use std::error::Error;
+
+use rstest::rstest;
+use serde_json::json;
+
+use super::tests::facts;
+
+#[test]
+fn retains_order_when_import_only_requests_repeat() -> Result<(), Box> {
+ // Given: only ordinary empty-specifier imports, including a duplicate.
+ let code = "import 'b'; import {} from 'a'; import 'b';";
+ // When: observation accompanies otherwise empty public facts.
+ let result = facts(code, true)?;
+ // Then: requests have first-insertion order and duplicates are removed.
+ assert_eq!(
+ result,
+ json!({
+ "references":[], "exports":[], "stars":[],
+ "observation": {"defaultCallable":false,"unsupportedRequests":[],"importOnlyRequests":["b","a"]},
+ })
+ );
+ Ok(())
+}
+
+#[rstest]
+#[case("")]
+#[case("'use client'; import 'a';")]
+#[case("import 'a'; ;")]
+#[case("import value from 'a';")]
+#[case("import 'a' with {type:'json'};")]
+#[case("import 'a' assert {type:'json'};")]
+fn omits_import_only_when_program_has_other_demand(
+ #[case] code: &str,
+) -> Result<(), Box> {
+ // Given: a program that cannot prove ordinary import-only demand.
+ // When: observation examines all statements and directives.
+ let result = facts(code, true)?;
+ // Then: the optional erasure proof is absent, rather than an empty set.
+ assert!(result["observation"].get("importOnlyRequests").is_none());
+ Ok(())
+}
+
+#[test]
+fn retains_unsupported_order_when_attributes_occur_on_imports_and_exports()
+-> Result<(), Box> {
+ // Given: import, named-forwarding and star attributes with repeated sources.
+ let code = "import 'b' with {type:'json'}; export {default as x} from 'a' with {type:'json'}; export * from 'b' with {type:'json'};";
+ // When: observation collects unsupported request shapes.
+ let result = facts(code, true)?;
+ // Then: ordered-set semantics include export attributes and deduplicate b.
+ assert_eq!(
+ result["observation"]["unsupportedRequests"],
+ json!(["b", "a"])
+ );
+ Ok(())
+}
+
+#[test]
+fn omits_observation_when_not_requested() -> Result<(), Box> {
+ // Given: a source whose callable proof would otherwise be observable.
+ // When: facts are requested without observation.
+ let result = facts("export default ()=>0", false)?;
+ // Then: only the established facts wire fields are present.
+ assert_eq!(
+ result,
+ json!({"references":[],"exports":[["default",null]],"stars":[]})
+ );
+ Ok(())
+}
diff --git a/libs/extractor/src/compiled_guard/origins.rs b/libs/extractor/src/compiled_guard/origins.rs
new file mode 100644
index 000000000..1f31ed5c9
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/origins.rs
@@ -0,0 +1,84 @@
+use oxc_ast::ast::{Argument, Expression, ModuleExportName, PropertyKey};
+
+use super::{scopes::Scopes, text::Text, wire::Origin};
+
+pub(super) fn origin(node: &Expression<'_>, scopes: &Scopes, scope: usize) -> Option {
+ match node {
+ Expression::Identifier(id) => scopes.binding(scope, id.name.as_str()),
+ Expression::CallExpression(call) => {
+ let Expression::Identifier(callee) = &call.callee else {
+ return None;
+ };
+ if callee.name != "require"
+ || scopes.owner(scope, "require").is_some()
+ || call.arguments.len() != 1
+ {
+ return None;
+ }
+ let Argument::StringLiteral(request) = &call.arguments[0] else {
+ return None;
+ };
+ if request.value.is_empty() {
+ return None;
+ }
+ Some(Origin {
+ request: Text::literal(request),
+ ids: Vec::new(),
+ require: true,
+ })
+ }
+ Expression::StaticMemberExpression(member) => {
+ let mut value = origin(&member.object, scopes, scope)?;
+ value.ids.push(Text::from(member.property.name.as_str()));
+ Some(value)
+ }
+ Expression::ComputedMemberExpression(member) => {
+ let name = literal_name(&member.expression)?;
+ let mut value = origin(&member.object, scopes, scope)?;
+ value.ids.push(name);
+ Some(value)
+ }
+ Expression::PrivateFieldExpression(member) => {
+ let mut value = origin(&member.object, scopes, scope)?;
+ value.ids.push(Text::from(member.field.name.as_str()));
+ Some(value)
+ }
+ _ => None,
+ }
+}
+
+pub(super) fn literal_name(node: &Expression<'_>) -> Option {
+ match node {
+ Expression::StringLiteral(value) => Some(Text::literal(value)),
+ Expression::BooleanLiteral(_)
+ | Expression::NullLiteral(_)
+ | Expression::NumericLiteral(_)
+ | Expression::BigIntLiteral(_)
+ | Expression::RegExpLiteral(_) => Some(Text::from("")),
+ _ => None,
+ }
+}
+
+pub(super) fn property_name(key: &PropertyKey<'_>, computed: bool) -> Option {
+ match key {
+ PropertyKey::StaticIdentifier(id) if !computed => Some(Text::from(id.name.as_str())),
+ PropertyKey::PrivateIdentifier(id) if !computed => Some(Text::from(id.name.as_str())),
+ _ => key.as_expression().and_then(literal_name),
+ }
+}
+
+pub(super) fn export_name(name: &ModuleExportName<'_>) -> Text {
+ match name {
+ ModuleExportName::IdentifierName(id) => Text::from(id.name.as_str()),
+ ModuleExportName::IdentifierReference(id) => Text::from(id.name.as_str()),
+ ModuleExportName::StringLiteral(value) => Text::literal(value),
+ }
+}
+
+pub(super) fn local_name<'n>(name: &'n ModuleExportName<'_>) -> Option<&'n str> {
+ match name {
+ ModuleExportName::IdentifierName(id) => Some(id.name.as_str()),
+ ModuleExportName::IdentifierReference(id) => Some(id.name.as_str()),
+ ModuleExportName::StringLiteral(_) => None,
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/patterns.rs b/libs/extractor/src/compiled_guard/patterns.rs
new file mode 100644
index 000000000..82ef1b635
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/patterns.rs
@@ -0,0 +1,56 @@
+use oxc_ast::ast::{AssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty};
+use oxc_ast_visit::Visit;
+
+use super::traversal::Collector;
+
+impl Collector {
+ pub fn assignment_pattern(&mut self, pattern: &AssignmentTarget<'_>) {
+ match pattern {
+ AssignmentTarget::ArrayAssignmentTarget(array) => {
+ for element in array.elements.iter().flatten() {
+ self.assignment_default(element);
+ }
+ if let Some(rest) = &array.rest {
+ self.assignment_pattern(&rest.target);
+ }
+ }
+ AssignmentTarget::ObjectAssignmentTarget(object) => {
+ for property in &object.properties {
+ match property {
+ AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(property) => {
+ if let Some(init) = &property.init {
+ self.visit_expression(init);
+ }
+ }
+ AssignmentTargetProperty::AssignmentTargetPropertyProperty(property) => {
+ if property.computed
+ && let Some(key) = property.name.as_expression()
+ {
+ self.visit_expression(key);
+ }
+ self.assignment_default(&property.binding);
+ }
+ }
+ }
+ if let Some(rest) = &object.rest {
+ self.assignment_pattern(&rest.target);
+ }
+ }
+ _ => {}
+ }
+ }
+
+ fn assignment_default(&mut self, target: &AssignmentTargetMaybeDefault<'_>) {
+ match target {
+ AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(default) => {
+ self.assignment_pattern(&default.binding);
+ self.visit_expression(&default.init);
+ }
+ _ => {
+ if let Some(target) = target.as_assignment_target() {
+ self.assignment_pattern(target);
+ }
+ }
+ }
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/reference_tests.rs b/libs/extractor/src/compiled_guard/reference_tests.rs
new file mode 100644
index 000000000..179534eb4
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/reference_tests.rs
@@ -0,0 +1,81 @@
+use std::error::Error;
+
+use rstest::rstest;
+use serde_json::json;
+
+use super::tests::facts;
+
+#[test]
+fn records_outer_path_when_namespace_members_are_nested() -> Result<(), Box> {
+ // Given: a chain whose inner member already has a definite origin.
+ let code = "import * as DU from 'ui'; DU.stylex.create({});";
+ // When: the member visitor records the outer origin.
+ let result = facts(code, false)?;
+ // Then: the complete path occurs once, without a duplicate inner read.
+ assert_eq!(
+ result["references"],
+ json!([
+ {"request":"ui","ids":["stylex","create"],"pos":26},
+ ])
+ );
+ Ok(())
+}
+
+#[rstest]
+#[case("import {css} from 'ui'; css[unknown];")]
+#[case("import {css} from 'ui'; const holder={}; [holder[css]]=[];")]
+#[case("import {css} from 'ui'; const obj={[css]:0}; class C{[css](){}}")]
+fn avoids_extra_reads_when_typescript_traversal_suppresses_them(
+ #[case] code: &str,
+) -> Result<(), Box> {
+ // Given: a dynamic member, a pattern member target or an identifier key.
+ // When: the narrow current traversal is reproduced, rather than broadened.
+ let result = facts(code, false)?;
+ // Then: suppressed subexpressions do not become definite references.
+ assert_eq!(result["references"], json!([]));
+ Ok(())
+}
+
+#[test]
+fn retains_literal_empty_names_when_computed_key_values_are_not_strings()
+-> Result<(), Box> {
+ // Given: nodeName ignores non-string Literal values in the TypeScript guard.
+ let code = "import * as DU from 'ui'; DU[1];";
+ // When: a numeric literal member is resolved.
+ let result = facts(code, false)?;
+ // Then: it retains the existing empty-name semantics, not numeric coercion.
+ assert_eq!(result["references"][0]["ids"], json!([""]));
+ Ok(())
+}
+
+#[test]
+fn retains_traversal_time_origins_when_exports_precede_aliases() -> Result<(), Box> {
+ // Given: an export before a const alias and a default export after it.
+ let code =
+ "import * as DU from 'ui'; export {Alias}; const Alias=DU.css; export default Alias;";
+ // When: const origins are seeded in original traversal order.
+ let result = facts(code, false)?;
+ // Then: the early export remains local while the later default gains origin.
+ assert_eq!(
+ result["exports"],
+ json!([
+ ["Alias",null], ["default",{"request":"ui","ids":["css"]}],
+ ])
+ );
+ Ok(())
+}
+
+#[test]
+fn retains_require_kind_when_default_forwards_a_member() -> Result<(), Box> {
+ // Given: a default directly exporting a definite require member.
+ // When: default export provenance is collected.
+ let result = facts("export default require('ui').css;", false)?;
+ // Then: export forwarding retains require-call resolution kind as well.
+ assert_eq!(
+ result["exports"],
+ json!([
+ ["default",{"request":"ui","ids":["css"],"kind":"require-call"}],
+ ])
+ );
+ Ok(())
+}
diff --git a/libs/extractor/src/compiled_guard/scopes.rs b/libs/extractor/src/compiled_guard/scopes.rs
new file mode 100644
index 000000000..35dac31be
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/scopes.rs
@@ -0,0 +1,188 @@
+use oxc_allocator::{Address, GetAddress};
+use oxc_ast::{
+ AstKind,
+ ast::{
+ BindingPattern, ClassType, FormalParameters, FunctionType, Program, VariableDeclarationKind,
+ },
+};
+use oxc_ast_visit::Visit;
+use rustc_hash::FxHashMap;
+
+use super::wire::Origin;
+
+pub(super) struct Scope {
+ pub parent: Option,
+ function: bool,
+ pub bindings: FxHashMap>,
+}
+
+pub(super) struct Scopes {
+ pub nodes: FxHashMap,
+ pub entries: Vec,
+ current: usize,
+ parents: Vec,
+}
+
+impl Scopes {
+ pub fn build(program: &Program<'_>) -> Self {
+ let mut scopes = Self {
+ nodes: FxHashMap::default(),
+ entries: vec![Scope {
+ parent: None,
+ function: true,
+ bindings: FxHashMap::default(),
+ }],
+ current: 0,
+ parents: Vec::new(),
+ };
+ scopes.visit_program(program);
+ scopes
+ }
+
+ pub fn at(&self, address: Address) -> usize {
+ self.nodes.get(&address).copied().unwrap_or(0)
+ }
+
+ pub fn owner(&self, mut scope: usize, name: &str) -> Option {
+ loop {
+ if self.entries[scope].bindings.contains_key(name) {
+ return Some(scope);
+ }
+ scope = self.entries[scope].parent?;
+ }
+ }
+
+ pub fn binding(&self, scope: usize, name: &str) -> Option {
+ let owner = self.owner(scope, name)?;
+ self.entries[owner].bindings.get(name)?.clone()
+ }
+
+ fn declare(&mut self, scope: usize, name: &str) {
+ self.entries[scope].bindings.insert(name.to_owned(), None);
+ }
+
+ fn pattern(&mut self, scope: usize, pattern: &BindingPattern<'_>) {
+ for name in pattern_names(pattern) {
+ self.declare(scope, &name);
+ }
+ }
+
+ fn parameters(&mut self, params: &FormalParameters<'_>) {
+ for param in ¶ms.items {
+ self.pattern(self.current, ¶m.pattern);
+ }
+ if let Some(rest) = ¶ms.rest {
+ self.pattern(self.current, &rest.rest.argument);
+ }
+ }
+}
+
+impl<'a> Visit<'a> for Scopes {
+ fn enter_node(&mut self, kind: AstKind<'a>) {
+ let parent = self.current;
+ self.parents.push(parent);
+ let function = matches!(
+ kind,
+ AstKind::Function(_) | AstKind::ArrowFunctionExpression(_)
+ );
+ let lexical = matches!(
+ kind,
+ AstKind::Class(_)
+ | AstKind::BlockStatement(_)
+ | AstKind::FunctionBody(_)
+ | AstKind::CatchClause(_)
+ | AstKind::ForStatement(_)
+ | AstKind::ForOfStatement(_)
+ | AstKind::ForInStatement(_)
+ | AstKind::StaticBlock(_)
+ | AstKind::SwitchStatement(_)
+ );
+ if function || lexical {
+ self.current = self.entries.len();
+ self.entries.push(Scope {
+ parent: Some(parent),
+ function,
+ bindings: FxHashMap::default(),
+ });
+ }
+ self.nodes.insert(kind.address(), self.current);
+ match kind {
+ AstKind::Function(node) => {
+ if let Some(id) = &node.id {
+ let target = match node.r#type {
+ FunctionType::FunctionDeclaration => parent,
+ FunctionType::FunctionExpression
+ | FunctionType::TSDeclareFunction
+ | FunctionType::TSEmptyBodyFunctionExpression => self.current,
+ };
+ self.declare(target, id.name.as_str());
+ }
+ self.parameters(&node.params);
+ }
+ AstKind::ArrowFunctionExpression(node) => self.parameters(&node.params),
+ AstKind::Class(node) => {
+ if let Some(id) = &node.id {
+ if node.r#type == ClassType::ClassDeclaration {
+ self.declare(parent, id.name.as_str());
+ }
+ self.declare(self.current, id.name.as_str());
+ }
+ }
+ AstKind::CatchClause(node) => {
+ if let Some(param) = &node.param {
+ self.pattern(self.current, ¶m.pattern);
+ }
+ }
+ AstKind::VariableDeclaration(node) => {
+ let mut target = self.current;
+ if node.kind == VariableDeclarationKind::Var {
+ while !self.entries[target].function
+ && let Some(parent) = self.entries[target].parent
+ {
+ target = parent;
+ }
+ }
+ for declaration in &node.declarations {
+ self.pattern(target, &declaration.id);
+ }
+ }
+ _ => {}
+ }
+ }
+
+ fn leave_node(&mut self, _kind: AstKind<'a>) {
+ if let Some(parent) = self.parents.pop() {
+ self.current = parent;
+ }
+ }
+}
+
+pub(super) fn pattern_names(pattern: &BindingPattern<'_>) -> Vec {
+ match pattern {
+ BindingPattern::BindingIdentifier(id) => vec![id.name.to_string()],
+ BindingPattern::AssignmentPattern(node) => pattern_names(&node.left),
+ BindingPattern::ObjectPattern(node) => {
+ let mut names: Vec<_> = node
+ .properties
+ .iter()
+ .flat_map(|property| pattern_names(&property.value))
+ .collect();
+ if let Some(rest) = &node.rest {
+ names.extend(pattern_names(&rest.argument));
+ }
+ names
+ }
+ BindingPattern::ArrayPattern(node) => {
+ let mut names: Vec<_> = node
+ .elements
+ .iter()
+ .flatten()
+ .flat_map(pattern_names)
+ .collect();
+ if let Some(rest) = &node.rest {
+ names.extend(pattern_names(&rest.argument));
+ }
+ names
+ }
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/tests.rs b/libs/extractor/src/compiled_guard/tests.rs
new file mode 100644
index 000000000..e483c973d
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/tests.rs
@@ -0,0 +1,179 @@
+use std::error::Error;
+
+use rstest::rstest;
+use serde_json::{Value, json};
+
+use super::compiled_guard_facts_internal;
+
+const REQUIRE_ASSIGNMENT_SOURCE: &str = "let c; ({css:c}=require('ui'))";
+const CATCH_SHADOW_SOURCE: &str = "import {css} from 'ui'; try{}catch({message:css}){css()}";
+
+pub(super) fn facts(code: &str, observe: bool) -> Result> {
+ Ok(serde_json::from_str(&compiled_guard_facts_internal(
+ code, observe,
+ )?)?)
+}
+
+#[rstest]
+#[case("import {css as c} from 'ui'; c()", false)]
+#[case("import * as DU from 'ui'; DU.css()", false)]
+#[case("import * as DU from 'ui'; DU['css']()", false)]
+#[case("import * as DU from 'ui'; const Alias=(DU); Alias.css()", false)]
+#[case("import * as DU from 'ui'; (DU).css()", false)]
+#[case("require('ui').css()", true)]
+#[case("const DU=require('ui'); const Alias=DU; Alias.css()", true)]
+#[case("const {css:c,...rest}=require('ui')", true)]
+#[case(REQUIRE_ASSIGNMENT_SOURCE, true)]
+fn retains_origins_when_statically_named(
+ #[case] code: &str,
+ #[case] require: bool,
+) -> Result<(), Box> {
+ // Given: a definite imported surface in final JavaScript.
+ // When: the source API collects facts.
+ let result = facts(code, false)?;
+ // Then: the request, export path and require kind are retained.
+ let references = result["references"]
+ .as_array()
+ .ok_or("references must be an array")?;
+ assert!(
+ references
+ .iter()
+ .any(|reference| reference["request"] == "ui"
+ && reference["ids"] == json!(["css"])
+ && reference.get("kind").and_then(Value::as_str)
+ == require.then_some("require-call"))
+ );
+ Ok(())
+}
+
+#[rstest]
+#[case("import * as DU from 'ui'; function f(DU){return DU.css()}")]
+#[case("import * as DU from 'ui'; { DU.css(); let DU; }")]
+#[case("function f(require){return require('ui').css()}")]
+#[case("function f(){ require('ui').css(); if(0){var require;} }")]
+#[case("const DU=require('ui'); DU[unknown]()")]
+#[case("const DU=import('ui'); DU.css()")]
+#[case("require('ui', extra).css()")]
+#[case("require('').css()")]
+#[case("import * as DU from 'ui'; class C { method(){var DU; return DU.css()} }")]
+#[case("import * as DU from 'ui'; const C=class DU { method(){return DU.css()} }")]
+#[case("import {css} from 'ui'; for(let css of []){css()}")]
+#[case(CATCH_SHADOW_SOURCE)]
+fn rejects_origins_when_opaque_or_predeclared_shadowed(
+ #[case] code: &str,
+) -> Result<(), Box> {
+ // Given: a source with no definite imported export read.
+ // When: scopes and origins are collected.
+ let result = facts(code, false)?;
+ // Then: no reference is manufactured.
+ assert_eq!(result["references"], json!([]));
+ Ok(())
+}
+
+#[test]
+fn preserves_order_when_aliases_are_declared_together() -> Result<(), Box> {
+ // Given: const alias propagation happens before visiting all initializers.
+ let code = "import {css} from 'ui'; const a=css,b=a; b();";
+ // When: the declaration is visited in the TypeScript order.
+ let result = facts(code, false)?;
+ // Then: initializer reads precede the later use, with exact positions.
+ assert_eq!(
+ result["references"],
+ json!([
+ {"request":"ui","ids":["css"],"pos":32},
+ {"request":"ui","ids":["css"],"pos":38},
+ {"request":"ui","ids":["css"],"pos":41},
+ ])
+ );
+ Ok(())
+}
+
+#[test]
+fn preserves_forwarding_when_exports_are_local_named_and_starred() -> Result<(), Box> {
+ // Given: public forwarding plus local declarations and a default import.
+ let code = "import {css} from 'ui'; export {css as style}; export {Box as Widget} from 'components'; export * from 'star'; export * as namespace from 'namespace'; export const {x:y=css,...rest}={}; export function local(){} export default css;";
+ // When: export entries are collected.
+ let result = facts(code, false)?;
+ // Then: insertion order and null local origins match the wire contract.
+ assert_eq!(
+ result["exports"],
+ json!([
+ ["style", {"request":"ui","ids":["css"]}],
+ ["Widget", {"request":"components","ids":["Box"]}],
+ ["namespace", {"request":"namespace","ids":[]}],
+ ["y",null], ["rest",null], ["local",null],
+ ["default", {"request":"ui","ids":["css"]}],
+ ])
+ );
+ assert_eq!(result["stars"], json!(["star"]));
+ Ok(())
+}
+
+#[test]
+fn visits_patterns_when_defaults_and_computed_keys_are_reads() -> Result<(), Box> {
+ // Given: binding names, computed keys, defaults and nested destructuring.
+ let code = "import {css} from 'ui'; function f({[css]: value=css},[head=css,,...tail]){const {nested:{x=css}}={};} let target; ({[css]:target=css}={});";
+ // When: pattern expressions alone are visited as reads.
+ let result = facts(code, false)?;
+ // Then: each of the six expression reads is retained once.
+ let refs = result["references"]
+ .as_array()
+ .ok_or("references must be an array")?;
+ assert_eq!(refs.len(), 6);
+ assert!(refs.iter().all(|value| value["ids"] == json!(["css"])));
+ Ok(())
+}
+
+#[test]
+fn measures_utf16_when_astral_text_precedes_a_read() -> Result<(), Box> {
+ // Given: one astral character before a namespace read.
+ let prefix = "import * as DU from 'ui'; '😀'; ";
+ let code = format!("{prefix}DU.css()");
+ // When: Oxc byte spans cross the JSON boundary.
+ let result = facts(&code, false)?;
+ // Then: the position counts UTF-16 units, not UTF-8 bytes.
+ assert_eq!(
+ result["references"][0]["pos"],
+ json!(prefix.encode_utf16().count())
+ );
+ Ok(())
+}
+
+#[test]
+fn retains_lone_surrogates_when_requests_and_keys_are_escaped() -> Result<(), Box> {
+ // Given: JavaScript strings that Rust UTF-8 cannot represent as values.
+ let code = r"import * as DU from '\ud800'; DU['\udfff']";
+ // When: wire text is encoded without a lossy UTF-8 conversion.
+ let result = compiled_guard_facts_internal(code, false)?;
+ // Then: JSON retains the original UTF-16 units, not replacement characters.
+ assert!(result.contains(r#""request":"\ud800""#));
+ assert!(result.contains(r#""ids":["\udfff"]"#));
+ assert!(!result.contains('�'));
+ Ok(())
+}
+
+#[rstest]
+#[case("const broken = ;")]
+#[case("const value: number = 1;")]
+fn returns_located_errors_when_final_js_is_invalid(#[case] code: &str) {
+ // Given: invalid JavaScript or uncompiled TypeScript.
+ // When: the source API parses final JavaScript.
+ let result = compiled_guard_facts_internal(code, false);
+ // Then: no fallback facts are returned, and the diagnostic is located.
+ assert!(matches!(result, Err(error) if error.to_string().starts_with("compiled output:1:")));
+}
+
+#[test]
+fn skips_jsx_names_when_only_brace_expressions_are_reads() -> Result<(), Box> {
+ // Given: JSX tag names are JSXIdentifier, not ordinary Identifier reads.
+ let code = "import {Box,css} from 'ui'; const view=;";
+ // When: JSX is accepted by the final JavaScript parser.
+ let result = facts(code, false)?;
+ // Then: only the expression-container read is collected.
+ let refs = result["references"]
+ .as_array()
+ .ok_or("references must be an array")?;
+ assert_eq!(refs.len(), 1);
+ assert_eq!(refs[0]["ids"], json!(["css"]));
+ Ok(())
+}
diff --git a/libs/extractor/src/compiled_guard/text.rs b/libs/extractor/src/compiled_guard/text.rs
new file mode 100644
index 000000000..aa8c96caa
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/text.rs
@@ -0,0 +1,55 @@
+use oxc_ast::ast::StringLiteral;
+
+/// Canonical JSON string text, including JavaScript's unpaired surrogates.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub(super) struct Text(String);
+
+impl Text {
+ pub fn json(&self) -> &str {
+ &self.0
+ }
+
+ pub fn literal(value: &StringLiteral<'_>) -> Self {
+ Self::encode(value.value.encode_utf16())
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.0 == "\"\""
+ }
+
+ pub fn is_default(&self) -> bool {
+ self.0 == "\"default\""
+ }
+
+ fn encode(units: impl Iterator- ) -> Self {
+ let mut text = String::from("\"");
+ for ch in char::decode_utf16(units) {
+ match ch {
+ Ok('"') => text.push_str("\\\""),
+ Ok('\\') => text.push_str("\\\\"),
+ Ok(ch) if ch <= '\u{1f}' => {
+ let mut scratch = [0; 2];
+ Self::escape(&mut text, ch.encode_utf16(&mut scratch)[0]);
+ }
+ Ok(ch) => text.push(ch),
+ Err(error) => Self::escape(&mut text, error.unpaired_surrogate()),
+ }
+ }
+ text.push('"');
+ Self(text)
+ }
+
+ fn escape(text: &mut String, unit: u16) {
+ const HEX: &[u8; 16] = b"0123456789abcdef";
+ text.push_str("\\u");
+ for shift in [12, 8, 4, 0] {
+ text.push(char::from(HEX[usize::from((unit >> shift) & 15)]));
+ }
+ }
+}
+
+impl From<&str> for Text {
+ fn from(value: &str) -> Self {
+ Self::encode(value.encode_utf16())
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/traversal.rs b/libs/extractor/src/compiled_guard/traversal.rs
new file mode 100644
index 000000000..9d3627c52
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/traversal.rs
@@ -0,0 +1,214 @@
+use oxc_allocator::{GetAddress, UnstableAddress};
+use oxc_ast::ast::{
+ AssignmentExpression, AssignmentTarget, AssignmentTargetProperty, BindingPattern,
+ BindingProperty, ComputedMemberExpression, ExportAllDeclaration, ExportDeclaration,
+ ExportDefaultDeclaration, ExportFromDeclaration, ExportNamedDeclaration, Expression,
+ IdentifierReference, ImportDeclaration, JSXElementName, ObjectProperty, PrivateFieldExpression,
+ PropertyKey, StaticMemberExpression, VariableDeclaration, VariableDeclarationKind,
+ VariableDeclarator,
+};
+use oxc_ast_visit::{Visit, walk};
+
+use super::{
+ callable::Callables,
+ origins::{literal_name, origin, property_name},
+ scopes::Scopes,
+ text::Text,
+ wire::{Facts, Origin, Positions},
+};
+
+pub(super) struct Collector {
+ pub scopes: Scopes,
+ pub facts: Facts,
+ pub callables: Option,
+ positions: Positions,
+}
+
+impl Collector {
+ pub fn new(scopes: Scopes, positions: Positions, observe: bool) -> Self {
+ Self {
+ scopes,
+ positions,
+ facts: Facts::new(observe),
+ callables: observe.then(Callables::default),
+ }
+ }
+
+ pub fn record(&mut self, value: Option, pos: u32) {
+ if let Some(value) = value.filter(|value| !value.ids.is_empty()) {
+ self.facts
+ .references
+ .push((value, self.positions.utf16(pos)));
+ }
+ }
+
+ fn member(&mut self, object: &Expression<'_>, name: Option, pos: u32) {
+ let scope = self.scopes.at(object.address());
+ let value = origin(object, &self.scopes, scope);
+ self.record(
+ value.clone().and_then(|mut value| {
+ value.ids.push(name?);
+ Some(value)
+ }),
+ pos,
+ );
+ if value.is_none() {
+ self.visit_expression(object);
+ }
+ }
+}
+
+impl<'a> Visit<'a> for Collector {
+ fn visit_import_declaration(&mut self, _node: &ImportDeclaration<'a>) {}
+
+ fn visit_identifier_reference(&mut self, node: &IdentifierReference<'a>) {
+ let scope = self.scopes.at(node.unstable_address());
+ self.record(
+ self.scopes.binding(scope, node.name.as_str()),
+ node.span.start,
+ );
+ }
+
+ fn visit_variable_declaration(&mut self, node: &VariableDeclaration<'a>) {
+ if node.kind == VariableDeclarationKind::Const {
+ let scope = self.scopes.at(node.unstable_address());
+ for declaration in &node.declarations {
+ if let (BindingPattern::BindingIdentifier(id), Some(init)) =
+ (&declaration.id, &declaration.init)
+ && let Some(value) = origin(init, &self.scopes, scope)
+ && let Some(owner) = self.scopes.owner(scope, id.name.as_str())
+ {
+ self.scopes.entries[owner]
+ .bindings
+ .insert(id.name.to_string(), Some(value));
+ }
+ }
+ }
+ walk::walk_variable_declaration(self, node);
+ }
+
+ fn visit_variable_declarator(&mut self, node: &VariableDeclarator<'a>) {
+ if let (BindingPattern::ObjectPattern(pattern), Some(init)) = (&node.id, &node.init) {
+ let scope = self.scopes.at(node.unstable_address());
+ if let Some(value) = origin(init, &self.scopes, scope) {
+ for property in &pattern.properties {
+ if let Some(name) = property_name(&property.key, property.computed) {
+ let mut value = value.clone();
+ value.ids.push(name);
+ self.record(Some(value), property.span.start);
+ }
+ }
+ }
+ }
+ walk::walk_variable_declarator(self, node);
+ }
+
+ fn visit_assignment_expression(&mut self, node: &AssignmentExpression<'a>) {
+ if let AssignmentTarget::ObjectAssignmentTarget(pattern) = &node.left {
+ let scope = self.scopes.at(node.unstable_address());
+ if let Some(value) = origin(&node.right, &self.scopes, scope) {
+ for property in &pattern.properties {
+ let (name, pos) = match property {
+ AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(property) => (
+ Some(Text::from(property.binding.name.as_str())),
+ property.span.start,
+ ),
+ AssignmentTargetProperty::AssignmentTargetPropertyProperty(property) => (
+ property_name(&property.name, property.computed),
+ property.span.start,
+ ),
+ };
+ if let Some(name) = name {
+ let mut value = value.clone();
+ value.ids.push(name);
+ self.record(Some(value), pos);
+ }
+ }
+ }
+ }
+ walk::walk_assignment_expression(self, node);
+ }
+
+ fn visit_static_member_expression(&mut self, node: &StaticMemberExpression<'a>) {
+ self.member(
+ &node.object,
+ Some(Text::from(node.property.name.as_str())),
+ node.span.start,
+ );
+ }
+
+ fn visit_private_field_expression(&mut self, node: &PrivateFieldExpression<'a>) {
+ self.member(
+ &node.object,
+ Some(Text::from(node.field.name.as_str())),
+ node.span.start,
+ );
+ }
+
+ fn visit_computed_member_expression(&mut self, node: &ComputedMemberExpression<'a>) {
+ let name = literal_name(&node.expression);
+ let computed = name.is_none();
+ self.member(&node.object, name, node.span.start);
+ if computed {
+ self.visit_expression(&node.expression);
+ }
+ }
+
+ fn visit_binding_property(&mut self, node: &BindingProperty<'a>) {
+ if node.computed
+ && let Some(key) = node.key.as_expression()
+ {
+ self.visit_expression(key);
+ }
+ self.visit_binding_pattern(&node.value);
+ }
+
+ fn visit_property_key(&mut self, node: &PropertyKey<'a>) {
+ if let Some(key) = node.as_expression()
+ && !matches!(key, Expression::Identifier(_))
+ {
+ self.visit_expression(key);
+ }
+ }
+
+ fn visit_jsx_element_name(&mut self, _node: &JSXElementName<'a>) {}
+
+ fn visit_object_property(&mut self, node: &ObjectProperty<'a>) {
+ if let Some(key) = node.key.as_expression()
+ && !matches!(key, Expression::Identifier(_))
+ {
+ self.visit_expression(key);
+ }
+ self.visit_expression(&node.value);
+ }
+
+ fn visit_assignment_target(&mut self, node: &AssignmentTarget<'a>) {
+ match node {
+ AssignmentTarget::ArrayAssignmentTarget(_)
+ | AssignmentTarget::ObjectAssignmentTarget(_) => self.assignment_pattern(node),
+ _ => walk::walk_assignment_target(self, node),
+ }
+ }
+
+ fn visit_export_named_declaration(&mut self, node: &ExportNamedDeclaration<'a>) {
+ self.named_export(node);
+ }
+
+ fn visit_export_from_declaration(&mut self, node: &ExportFromDeclaration<'a>) {
+ self.forward_export(node);
+ }
+
+ fn visit_export_declaration(&mut self, node: &ExportDeclaration<'a>) {
+ self.declared_export(&node.declaration);
+ self.visit_declaration(&node.declaration);
+ }
+
+ fn visit_export_all_declaration(&mut self, node: &ExportAllDeclaration<'a>) {
+ self.star_export(node);
+ }
+
+ fn visit_export_default_declaration(&mut self, node: &ExportDefaultDeclaration<'a>) {
+ self.default_export(node);
+ walk::walk_export_default_declaration(self, node);
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/wire.rs b/libs/extractor/src/compiled_guard/wire.rs
new file mode 100644
index 000000000..dd8886bae
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/wire.rs
@@ -0,0 +1,150 @@
+use super::text::Text;
+use rustc_hash::FxHashMap;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(super) struct Origin {
+ pub request: Text,
+ pub ids: Vec,
+ pub require: bool,
+}
+
+impl Origin {
+ fn fields(&self, out: &mut String) {
+ out.push_str("\"request\":");
+ out.push_str(self.request.json());
+ out.push_str(",\"ids\":");
+ strings(out, &self.ids);
+ if self.require {
+ out.push_str(",\"kind\":\"require-call\"");
+ }
+ }
+}
+
+#[derive(Default)]
+pub(super) struct Facts {
+ pub references: Vec<(Origin, usize)>,
+ pub exports: Vec<(Text, Option)>,
+ pub stars: Vec,
+ pub observation: Option,
+ export_indices: FxHashMap,
+}
+
+#[derive(Default)]
+pub(super) struct Observation {
+ pub default_callable: bool,
+ pub unsupported_requests: Vec,
+ pub import_only_requests: Option>,
+}
+
+impl Facts {
+ pub fn new(observe: bool) -> Self {
+ Self {
+ observation: observe.then(Observation::default),
+ ..Self::default()
+ }
+ }
+
+ pub fn export(&mut self, name: Text, origin: Option) {
+ if let Some(index) = self.export_indices.get(&name) {
+ self.exports[*index].1 = origin;
+ } else {
+ self.export_indices.insert(name.clone(), self.exports.len());
+ self.exports.push((name, origin));
+ }
+ }
+
+ pub fn json(&self) -> String {
+ let mut out = String::from("{\"references\":[");
+ for (index, (origin, pos)) in self.references.iter().enumerate() {
+ separator(&mut out, index);
+ out.push('{');
+ origin.fields(&mut out);
+ out.push_str(",\"pos\":");
+ out.push_str(&pos.to_string());
+ out.push('}');
+ }
+ out.push_str("],\"exports\":[");
+ for (index, (name, origin)) in self.exports.iter().enumerate() {
+ separator(&mut out, index);
+ out.push('[');
+ out.push_str(name.json());
+ out.push(',');
+ match origin {
+ Some(origin) => {
+ out.push('{');
+ origin.fields(&mut out);
+ out.push('}');
+ }
+ None => out.push_str("null"),
+ }
+ out.push(']');
+ }
+ out.push_str("],\"stars\":");
+ strings(&mut out, &self.stars);
+ if let Some(observation) = &self.observation {
+ out.push_str(",\"observation\":{\"defaultCallable\":");
+ out.push_str(if observation.default_callable {
+ "true"
+ } else {
+ "false"
+ });
+ out.push_str(",\"unsupportedRequests\":");
+ strings(&mut out, &observation.unsupported_requests);
+ if let Some(requests) = &observation.import_only_requests {
+ out.push_str(",\"importOnlyRequests\":");
+ strings(&mut out, requests);
+ }
+ out.push('}');
+ }
+ out.push('}');
+ out
+ }
+}
+
+fn separator(out: &mut String, index: usize) {
+ if index > 0 {
+ out.push(',');
+ }
+}
+
+fn strings(out: &mut String, values: &[Text]) {
+ out.push('[');
+ for (index, text) in values.iter().enumerate() {
+ separator(out, index);
+ out.push_str(text.json());
+ }
+ out.push(']');
+}
+
+/// Sparse corrections keep ASCII modules allocation-free for offset conversion.
+pub(super) struct Positions {
+ corrections: Vec<(usize, usize)>,
+}
+
+impl Positions {
+ pub fn new(code: &str) -> Self {
+ let mut corrections = Vec::new();
+ let mut excess = 0;
+ for (byte, ch) in code.char_indices().filter(|(_, ch)| !ch.is_ascii()) {
+ excess += ch.len_utf8() - ch.len_utf16();
+ corrections.push((byte + ch.len_utf8(), excess));
+ }
+ Self { corrections }
+ }
+
+ pub fn utf16(&self, byte: u32) -> usize {
+ let byte = usize::try_from(byte).unwrap_or(usize::MAX);
+ let index = self.corrections.partition_point(|(end, _)| *end <= byte);
+ let excess = index
+ .checked_sub(1)
+ .and_then(|at| self.corrections.get(at))
+ .map_or(0, |(_, excess)| *excess);
+ byte - excess
+ }
+}
+
+pub(super) fn insert_request(requests: &mut Vec, request: Text) {
+ if !requests.contains(&request) {
+ requests.push(request);
+ }
+}
diff --git a/libs/extractor/src/compiled_guard/writes.rs b/libs/extractor/src/compiled_guard/writes.rs
new file mode 100644
index 000000000..637d2b28c
--- /dev/null
+++ b/libs/extractor/src/compiled_guard/writes.rs
@@ -0,0 +1,107 @@
+use oxc_allocator::GetAddress;
+use oxc_ast::{
+ AstKind,
+ ast::{
+ AssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty, Expression,
+ SimpleAssignmentTarget,
+ },
+};
+use oxc_ast_visit::Visit;
+
+use super::{
+ callable::{Callables, Proof},
+ scopes::Scopes,
+};
+
+pub(super) struct Writes<'s> {
+ pub scopes: &'s Scopes,
+ pub callables: &'s mut Callables,
+}
+
+impl Writes<'_> {
+ fn name(&mut self, scope: usize, name: &str) {
+ if self.scopes.owner(scope, name) == Some(0) {
+ self.callables.locals.remove(name);
+ }
+ }
+
+ fn target(&mut self, target: &AssignmentTarget<'_>, scope: usize) {
+ match target {
+ AssignmentTarget::AssignmentTargetIdentifier(id) => self.name(scope, id.name.as_str()),
+ AssignmentTarget::ArrayAssignmentTarget(array) => {
+ for element in array.elements.iter().flatten() {
+ self.default_target(element, scope);
+ }
+ if let Some(rest) = &array.rest {
+ self.target(&rest.target, scope);
+ }
+ }
+ AssignmentTarget::ObjectAssignmentTarget(object) => {
+ for property in &object.properties {
+ match property {
+ AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(property) => {
+ self.name(scope, property.binding.name.as_str());
+ }
+ AssignmentTargetProperty::AssignmentTargetPropertyProperty(property) => {
+ self.default_target(&property.binding, scope);
+ }
+ }
+ }
+ if let Some(rest) = &object.rest {
+ self.target(&rest.target, scope);
+ }
+ }
+ _ => {}
+ }
+ }
+
+ fn default_target(&mut self, target: &AssignmentTargetMaybeDefault<'_>, scope: usize) {
+ match target {
+ AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(default) => {
+ self.target(&default.binding, scope);
+ }
+ _ => {
+ if let Some(target) = target.as_assignment_target() {
+ self.target(target, scope);
+ }
+ }
+ }
+ }
+}
+
+impl<'a> Visit<'a> for Writes<'_> {
+ fn enter_node(&mut self, kind: AstKind<'a>) {
+ let scope = self.scopes.at(kind.address());
+ match kind {
+ AstKind::AssignmentExpression(node) => self.target(&node.left, scope),
+ AstKind::UpdateExpression(node) => {
+ if let SimpleAssignmentTarget::AssignmentTargetIdentifier(id) = &node.argument {
+ self.name(scope, id.name.as_str());
+ }
+ }
+ AstKind::ForOfStatement(node) => {
+ if let Some(target) = node.left.as_assignment_target() {
+ self.target(target, scope);
+ }
+ }
+ AstKind::ForInStatement(node) => {
+ if let Some(target) = node.left.as_assignment_target() {
+ self.target(target, scope);
+ }
+ }
+ AstKind::CallExpression(node) => {
+ if let Expression::Identifier(callee) = &node.callee
+ && callee.name == "eval"
+ && !node.optional
+ && self.scopes.owner(scope, "eval").is_none()
+ {
+ self.callables.locals.retain(|name, proof| {
+ !matches!(proof, Proof::Declaration(_, _))
+ || self.scopes.owner(scope, name) != Some(0)
+ });
+ }
+ }
+ _ => {}
+ }
+ }
+}
diff --git a/libs/extractor/src/css_composition_rest_tests.rs b/libs/extractor/src/css_composition_rest_tests.rs
index 5f401c713..65fd1af0c 100644
--- a/libs/extractor/src/css_composition_rest_tests.rs
+++ b/libs/extractor/src/css_composition_rest_tests.rs
@@ -307,6 +307,7 @@ fn layers_stay_distinct_when_nested_spreads_override_matching_rules() {
map: None,
css_file: None,
dependencies: vec![],
+ deferred_defaults: vec![],
};
let styles = result_styles(&output, true);
assert_eq!(
diff --git a/libs/extractor/src/dead_properties/calls.rs b/libs/extractor/src/dead_properties/calls.rs
index 36c146bfb..16cdf384f 100644
--- a/libs/extractor/src/dead_properties/calls.rs
+++ b/libs/extractor/src/dead_properties/calls.rs
@@ -14,14 +14,10 @@ pub(crate) fn instrument(
code: &str,
filename: &str,
package: &str,
+ source_type: oxc_span::SourceType,
) -> Result {
let allocator = oxc_allocator::Allocator::default();
- let parsed = oxc_parser::Parser::new(
- &allocator,
- code,
- oxc_span::SourceType::from_path(filename).unwrap_or_else(|_| oxc_span::SourceType::ts()),
- )
- .parse();
+ let parsed = oxc_parser::Parser::new(&allocator, code, source_type).parse();
let semantic = oxc_semantic::SemanticBuilder::new()
.build(&parsed.program)
.semantic;
diff --git a/libs/extractor/src/dead_properties/origin.rs b/libs/extractor/src/dead_properties/origin.rs
index a7b806341..b6ea17b52 100644
--- a/libs/extractor/src/dead_properties/origin.rs
+++ b/libs/extractor/src/dead_properties/origin.rs
@@ -32,6 +32,7 @@ pub(crate) fn evaluated_calls(
source: &str,
filename: &str,
option: &ExtractOption,
+ source_type: oxc_span::SourceType,
) -> Vec<(usize, usize)> {
let Aliased {
code: aliased,
@@ -42,8 +43,9 @@ pub(crate) fn evaluated_calls(
filename,
&option.package,
&option.import_aliases,
+ source_type,
);
- match super::instrument(&aliased, filename, &option.package) {
+ match super::instrument(&aliased, filename, &option.package, source_type) {
Ok(instrumented) => instrumented
.calls
.into_iter()
diff --git a/libs/extractor/src/dead_properties_call_boundary_tests.rs b/libs/extractor/src/dead_properties_call_boundary_tests.rs
index 3aa2bbe42..2308030eb 100644
--- a/libs/extractor/src/dead_properties_call_boundary_tests.rs
+++ b/libs/extractor/src/dead_properties_call_boundary_tests.rs
@@ -32,8 +32,13 @@ fn ordinary_import_calls_keep_their_behavior_when_not_styling_apis(
let source = format!("{import}\n{call};");
// When: instrument actual parsed source, then execute its call with ordinary functions.
- let instrumented = dead_properties::instrument(&source, "ordinary.ts", "@devup-ui/react")
- .map_err(io::Error::other)?;
+ let instrumented = dead_properties::instrument(
+ &source,
+ "ordinary.ts",
+ "@devup-ui/react",
+ oxc_span::SourceType::ts(),
+ )
+ .map_err(io::Error::other)?;
let (_, body) = instrumented
.code
.split_once('\n')
@@ -55,8 +60,13 @@ fn direct_eval_keeps_lexical_scope_when_nested_calls_are_instrumented() -> Resul
let source = "function inspect() { eval(String('var local = 42')); return local; } inspect();";
// When: execute the real instrumented program, including the nested String call.
- let instrumented = dead_properties::instrument(source, "eval.ts", "@devup-ui/react")
- .map_err(io::Error::other)?;
+ let instrumented = dead_properties::instrument(
+ source,
+ "eval.ts",
+ "@devup-ui/react",
+ oxc_span::SourceType::ts(),
+ )
+ .map_err(io::Error::other)?;
let result = evaluate_instrumented(&instrumented.code)?;
// Then: the declaration belongs to inspect, not an instrumentation thunk.
@@ -70,8 +80,13 @@ fn suspending_call_keeps_generator_resume_value() -> Result<(), Box>
let source = "const echo = value => value; function* values() { return echo(yield echo(7)); } const iter = values(); iter.next(); iter.next(13).value;";
// When: instrument and execute valid generator source.
- let instrumented = dead_properties::instrument(source, "yield.ts", "@devup-ui/react")
- .map_err(io::Error::other)?;
+ let instrumented = dead_properties::instrument(
+ source,
+ "yield.ts",
+ "@devup-ui/react",
+ oxc_span::SourceType::ts(),
+ )
+ .map_err(io::Error::other)?;
let result = evaluate_instrumented(&instrumented.code)?;
// Then: yield remains in the generator body and the resumed argument reaches echo.
@@ -95,7 +110,12 @@ fn evaluated_call_mapping_has_no_ranges_when_authored_declarations_are_rejected(
};
// When: request evaluated origins for a source that cannot be evaluated.
- let calls = dead_properties::evaluated_calls(source, "rejected.tsx", &option);
+ let calls = dead_properties::evaluated_calls(
+ source,
+ "rejected.tsx",
+ &option,
+ oxc_span::SourceType::tsx(),
+ );
// Then: there are no partial ranges to misattribute the authored diagnostic.
assert_eq!(calls, vec![]);
diff --git a/libs/extractor/src/dead_properties_origin_tests.rs b/libs/extractor/src/dead_properties_origin_tests.rs
index 4adf9d8d3..4e6c68161 100644
--- a/libs/extractor/src/dead_properties_origin_tests.rs
+++ b/libs/extractor/src/dead_properties_origin_tests.rs
@@ -1,5 +1,7 @@
use crate::dead_properties_test_utils::{failure, position};
-use crate::{ExtractOption, ImportAlias, ResolvedModule, extract, extract_with_modules};
+use crate::{
+ ExtractOption, ImportAlias, ModuleResolution, ResolvedModule, extract, extract_with_modules,
+};
use css::{class_map::reset_class_map, file_map::reset_file_map};
use rstest::rstest;
use serial_test::serial;
@@ -97,10 +99,11 @@ fn imported_helper_call_keeps_its_authored_filename() {
let source = "import { style } from '@vanilla-extract/css';\nimport { make } from './helper';\nexport const c = style(make());";
let resolver = |specifier: &str, _: &str| {
match specifier {
- "./helper" => Some(ResolvedModule {
+ "./helper" => Some(ModuleResolution::Resolved(ResolvedModule {
+ source_type: None,
path: "helper.ts".to_string(),
code: "import { style } from '@vanilla-extract/css';\nconst key = 'box' + 'Orient';\nexport const make = () => style({ [key]: 'vertical' });".to_string(),
- }),
+ })),
_ => None,
}
};
@@ -124,10 +127,11 @@ fn imported_stylesheet_call_keeps_its_authored_filename() {
let source = "import { style } from '@vanilla-extract/css';\nimport { c } from './other.css';\nexport const result = style([c, { color: 'red' }]);";
let resolver = |specifier: &str, _: &str| {
match specifier {
- "./other.css" => Some(ResolvedModule {
+ "./other.css" => Some(ModuleResolution::Resolved(ResolvedModule {
+ source_type: None,
path: "other.css.ts".to_string(),
code: "import { style } from '@vanilla-extract/css';\nconst key = 'box' + 'Orient';\nexport const c = style({ [key]: 'vertical' });".to_string(),
- }),
+ })),
_ => None,
}
};
@@ -156,11 +160,12 @@ fn imported_objects_report_the_authored_styling_call(#[case] statement: &str, #[
"import {{ Box, css, keyframes, globalCss, styled }} from '@devup-ui/react';\nimport {{ rules }} from './rules';\n{statement}"
);
let resolver = |specifier: &str, _: &str| match specifier {
- "./rules" => Some(ResolvedModule {
+ "./rules" => Some(ModuleResolution::Resolved(ResolvedModule {
+ source_type: None,
path: "rules.ts".to_string(),
code: "export const rules = { selectors: { '&:hover': { boxOrient: 'vertical' } } };"
.to_string(),
- }),
+ })),
_ => None,
};
@@ -233,10 +238,11 @@ fn required_module_specifiers_keep_authored_locations(
"// Authored module, not generated JavaScript.\nconst unused: number = 1; const notModule = '{specifier}'; Math.max(1, 2); Number(0); function ignored(require: (x: string) => void) {{ require('{specifier}'); }} function optional() {{ require(0); }}\n {before}'{specifier}'{after}"
);
let resolver = move |specifier: &str, _: &str| match specifier {
- "./required" => Some(ResolvedModule {
+ "./required" => Some(crate::ModuleResolution::Resolved(ResolvedModule {
path: "required.ts".to_string(),
code: required.clone(),
- }),
+ source_type: None,
+ })),
_ => None,
};
@@ -272,14 +278,16 @@ fn required_module_specifiers_accept_complete_surrogate_pairs(
reset_file_map();
let required = format!("\nconst unused: number = 1;\n {before}'\\uD83D\\uDE00'{after}");
let resolver = move |specifier: &str, _: &str| match specifier {
- "./required" => Some(ResolvedModule {
+ "./required" => Some(crate::ModuleResolution::Resolved(ResolvedModule {
path: "required.ts".to_string(),
code: required.clone(),
- }),
- "😀" => Some(ResolvedModule {
+ source_type: None,
+ })),
+ "😀" => Some(crate::ModuleResolution::Resolved(ResolvedModule {
path: "rules.ts".to_string(),
code: "export const rules = { color: 'red' };".to_string(),
- }),
+ source_type: None,
+ })),
_ => None,
};
@@ -343,10 +351,11 @@ fn type_only_module_refusal_reports_required_site(
"// Original helper source.\n{erased}'{specifier}';\nconst unused: number = 1;\n import {{ rules }} from '{specifier}';\nexport {{ rules }};"
);
let resolver = move |specifier: &str, _: &str| match specifier {
- "./required" => Some(ResolvedModule {
+ "./required" => Some(crate::ModuleResolution::Resolved(ResolvedModule {
path: "required-types.ts".to_string(),
code: required.clone(),
- }),
+ source_type: None,
+ })),
_ => None,
};
@@ -383,14 +392,16 @@ fn type_only_module_declarations_allow_required_rules(
"// Original helper source.\n{erased}'{specifier}';\nconst unused: number = 1;\n import {{ rules }} from '\\uD83D\\uDE00';\nexport {{ rules }};"
);
let resolver = move |specifier: &str, _: &str| match specifier {
- "./required" => Some(ResolvedModule {
+ "./required" => Some(crate::ModuleResolution::Resolved(ResolvedModule {
path: "required-types.ts".to_string(),
code: required.clone(),
- }),
- "😀" => Some(ResolvedModule {
+ source_type: None,
+ })),
+ "😀" => Some(crate::ModuleResolution::Resolved(ResolvedModule {
path: "rules.ts".to_string(),
code: "export const rules = { color: 'red' };".to_string(),
- }),
+ source_type: None,
+ })),
_ => None,
};
diff --git a/libs/extractor/src/dead_properties_responsive_origin_tests.rs b/libs/extractor/src/dead_properties_responsive_origin_tests.rs
index 014c051f9..a386e3ca5 100644
--- a/libs/extractor/src/dead_properties_responsive_origin_tests.rs
+++ b/libs/extractor/src/dead_properties_responsive_origin_tests.rs
@@ -1,6 +1,8 @@
use crate::dead_properties_test_utils::{failure, position};
use crate::utils::{RESPONSIVE_ARRAY, build_time_error};
-use crate::{ExtractOption, ImportAlias, ResolvedModule, extract, extract_with_modules};
+use crate::{
+ ExtractOption, ImportAlias, ModuleResolution, ResolvedModule, extract, extract_with_modules,
+};
use css::{class_map::reset_class_map, file_map::reset_file_map};
use rstest::rstest;
use serial_test::serial;
@@ -124,10 +126,11 @@ fn imported_nested_arrays_report_the_consuming_stylesheet_call(
);
let module = format!("export const {export}={value};");
let resolver = move |specifier: &str, _: &str| match specifier {
- "./values" => Some(ResolvedModule {
+ "./values" => Some(ModuleResolution::Resolved(ResolvedModule {
+ source_type: None,
path: "values.ts".to_string(),
code: module.clone(),
- }),
+ })),
_ => None,
};
@@ -163,10 +166,11 @@ fn imported_stylesheet_nested_arrays_keep_the_declaring_call_origin() {
let source = "import {style} from '@vanilla-extract/css';\nimport {bad} from './other.css';\nexport const result=style([bad,{color:'red'}]);";
let resolver = |specifier: &str, _: &str| {
match specifier {
- "./other.css" => Some(ResolvedModule {
+ "./other.css" => Some(ModuleResolution::Resolved(ResolvedModule {
+ source_type: None,
path: "other.css.ts".to_string(),
code: concat!("import {style} from '@vanilla-extract/css';\nconst values=[[1,2],3];\n\n\nexport const bad = style(", "{", "p:values", "}", ");").to_string(),
- }),
+ })),
_ => None,
}
};
diff --git a/libs/extractor/src/emotion_namespace/driver.rs b/libs/extractor/src/emotion_namespace/driver.rs
index dc282f268..59ba04ae7 100644
--- a/libs/extractor/src/emotion_namespace/driver.rs
+++ b/libs/extractor/src/emotion_namespace/driver.rs
@@ -6,6 +6,7 @@ use oxc_ast::ast::{
Declaration, ImportDeclaration, ImportDeclarationSpecifier, Statement,
TSImportEqualsDeclaration, TSModuleReference,
};
+use oxc_span::SourceType;
fn is_emotion_require(declaration: &TSImportEqualsDeclaration<'_>) -> bool {
!declaration.import_kind.is_type()
@@ -105,7 +106,7 @@ impl Normalizer<'_, '_> {
/// Lower only the enabled root Emotion alias; offsets belong to the input source.
pub(crate) fn normalize<'a>(
code: &'a str,
- filename: &str,
+ source_type: SourceType,
aliases: &HashMap,
) -> Result, Errors> {
if aliases.get("@emotion/css") != Some(&ImportAlias::NamedToNamed)
@@ -114,12 +115,7 @@ pub(crate) fn normalize<'a>(
return Ok((Cow::Borrowed(code), vec![]));
}
let allocator = Allocator::default();
- let parsed = Parser::new(
- &allocator,
- code,
- crate::parsing::source_type(filename).unwrap_or_default(),
- )
- .parse();
+ let parsed = Parser::new(&allocator, code, source_type).parse();
let semantic = SemanticBuilder::new()
.with_build_nodes(true)
.build(&parsed.program)
diff --git a/libs/extractor/src/emotion_namespace/output.rs b/libs/extractor/src/emotion_namespace/output.rs
index 6cf4ee0e7..11c2e7266 100644
--- a/libs/extractor/src/emotion_namespace/output.rs
+++ b/libs/extractor/src/emotion_namespace/output.rs
@@ -1,6 +1,7 @@
use super::{Allocator, Edit, Parser};
use crate::{ExtractOutput, source_map};
use oxc_codegen::{Codegen, CodegenOptions};
+use oxc_span::SourceType;
use rustc_hash::FxHashSet;
use std::path::PathBuf;
@@ -9,6 +10,7 @@ use std::path::PathBuf;
/// back to `source`.
pub(crate) struct Rewritten<'a> {
pub filename: &'a str,
+ pub source_type: SourceType,
pub code: &'a str,
pub source: &'a str,
pub edits: &'a [&'a [Edit]],
@@ -18,13 +20,9 @@ impl Rewritten<'_> {
/// Generated from the rewritten module, so the map points at `source`.
pub(crate) fn output(&self) -> ExtractOutput {
let allocator = Allocator::default();
- let mut program = Parser::new(
- &allocator,
- self.code,
- crate::parsing::source_type(self.filename).unwrap_or_default(),
- )
- .parse()
- .program;
+ let mut program = Parser::new(&allocator, self.code, self.source_type)
+ .parse()
+ .program;
crate::jsx_pragmas::HeaderPragmas::capture(&program).reanchor(&mut program);
let result = Codegen::new()
.with_options(CodegenOptions {
@@ -40,6 +38,7 @@ impl Rewritten<'_> {
}),
css_file: None,
dependencies: Vec::new(),
+ deferred_defaults: Vec::new(),
}
}
}
diff --git a/libs/extractor/src/emotion_namespace/units.rs b/libs/extractor/src/emotion_namespace/units.rs
index c0d68bc6b..436eaf5aa 100644
--- a/libs/extractor/src/emotion_namespace/units.rs
+++ b/libs/extractor/src/emotion_namespace/units.rs
@@ -9,7 +9,7 @@ use oxc_ast::{
};
use oxc_ast_visit::{VisitMut, walk_mut};
use oxc_parser::Parser;
-use oxc_span::{GetSpan, SourceType};
+use oxc_span::GetSpan;
struct Units<'a> {
ast: AstBuilder<'a>,
@@ -87,7 +87,7 @@ impl<'a> VisitMut<'a> for Units<'a> {
/// Preserve Emotion units for values reduced by the constant inliner.
pub(crate) fn pixelify<'a>(allocator: &'a Allocator, program: &mut Program<'a>, original: &str) {
let source_allocator = Allocator::default();
- let source = Parser::new(&source_allocator, original, SourceType::tsx())
+ let source = Parser::new(&source_allocator, original, program.source_type)
.parse()
.program;
let mut calls = Vec::new();
@@ -118,6 +118,7 @@ pub(crate) fn pixelify<'a>(allocator: &'a Allocator, program: &mut Program<'a>,
mod tests {
use super::*;
use oxc_codegen::Codegen;
+ use oxc_span::SourceType;
use rstest::rstest;
#[rstest]
diff --git a/libs/extractor/src/emotion_namespace_tests/coverage.rs b/libs/extractor/src/emotion_namespace_tests/coverage.rs
index b89991af1..b60a564a4 100644
--- a/libs/extractor/src/emotion_namespace_tests/coverage.rs
+++ b/libs/extractor/src/emotion_namespace_tests/coverage.rs
@@ -9,7 +9,7 @@ fn aliases() -> HashMap {
}
fn normalized(code: &str) -> Result {
- emotion_namespace::normalize(code, "namespace.tsx", &aliases())
+ emotion_namespace::normalize(code, oxc_span::SourceType::tsx(), &aliases())
.map(|(code, _)| code.into_owned())
.map_err(|errors| format!("{errors:?}"))
}
diff --git a/libs/extractor/src/extractor/known_mixin_execution_tests.rs b/libs/extractor/src/extractor/known_mixin_execution_tests.rs
index 469fd3e1b..5833e578d 100644
--- a/libs/extractor/src/extractor/known_mixin_execution_tests.rs
+++ b/libs/extractor/src/extractor/known_mixin_execution_tests.rs
@@ -118,10 +118,11 @@ fn deep_namespace_when_given_css_prop_does_not_inherit_one_level_definition()
// Given
let source = "/** @jsxImportSource @emotion/react */ import * as UI from './base'; export const result = ;";
let resolver = |specifier: &str, _: &str| {
- (specifier == "./base").then(|| ResolvedModule {
+ (specifier == "./base").then(|| crate::ModuleResolution::Resolved(ResolvedModule {
path: "/composition/base.tsx".into(),
code: "import styled from '@emotion/styled'; export const Child = styled.div`color: red;`;".into(),
- })
+ source_type: None,
+ }))
};
// When
let output = extract_with_modules(
@@ -153,10 +154,11 @@ fn unknown_namespace_selector_when_not_an_exact_member_reports_error(
"import styled from '@emotion/styled'; import * as UI from './base'; export const result = styled.div`${{{selector}}} {{ color: blue; }}`;"
);
let resolver = |specifier: &str, _: &str| {
- (specifier == "./base").then(|| ResolvedModule {
+ (specifier == "./base").then(|| crate::ModuleResolution::Resolved(ResolvedModule {
path: "/composition/base.tsx".into(),
code: "import styled from '@emotion/styled'; export const Child = styled.div`color: red;`;".into(),
- })
+ source_type: None,
+ }))
};
// When
let error = extract_with_modules(
diff --git a/libs/extractor/src/extractor/known_mixin_tests.rs b/libs/extractor/src/extractor/known_mixin_tests.rs
index 38fc249e1..da8aef297 100644
--- a/libs/extractor/src/extractor/known_mixin_tests.rs
+++ b/libs/extractor/src/extractor/known_mixin_tests.rs
@@ -25,9 +25,12 @@ fn imported(base: &str, body: &str) -> ExtractOutput {
let entry =
format!("import styled from '@emotion/styled'; import {{ Base }} from './base'; {body}");
let resolver = move |specifier: &str, _: &str| {
- (specifier == "./base").then(|| ResolvedModule {
- path: "/composition/base.tsx".to_string(),
- code: module.clone(),
+ (specifier == "./base").then(|| {
+ crate::ModuleResolution::Resolved(ResolvedModule {
+ path: "/composition/base.tsx".to_string(),
+ code: module.clone(),
+ source_type: None,
+ })
})
};
crate::extract_with_modules("/composition/entry.tsx", &entry, option(), false, &resolver)
diff --git a/libs/extractor/src/ignored_loader_tests.rs b/libs/extractor/src/ignored_loader_tests.rs
new file mode 100644
index 000000000..362aa00b3
--- /dev/null
+++ b/libs/extractor/src/ignored_loader_tests.rs
@@ -0,0 +1,77 @@
+use super::*;
+
+#[test]
+fn ignored_loader_when_imported_or_reexported_has_empty_namespace() -> Result<(), String> {
+ let resolver = |specifier: &str, _: &str| {
+ match specifier {
+ "empty" => Some(ModuleResolution::Ignored),
+ "barrel" => Some(ModuleResolution::Resolved(crate::ResolvedModule {
+ path: "/src/barrel.js".to_string(),
+ code: "export {default as def, missing as value, __exports__ as hidden} from 'empty'; export * as ns from 'empty'; export * from 'empty';".to_string(),
+ source_type: None,
+ })),
+ "cjs" => Some(ModuleResolution::Resolved(crate::ResolvedModule {
+ path: "/src/cjs.js".to_string(),
+ code: "const first = require('empty'); const second = require('empty'); const {missing} = require('empty'); module.exports = {ok: first === second && Object.keys(first).length === 0 && first.missing === undefined && missing === undefined};".to_string(),
+ source_type: None,
+ })),
+ _ => None,
+ }
+ };
+ let option = ExtractOption::default();
+ let mut loader = ModuleLoader::new(Some(&resolver), &option);
+ let code = "import def, {missing, __exports__ as hidden} from 'empty'; import * as ns from 'empty'; import * as barrel from 'barrel'; import cjs from 'cjs'; const ok = missing === undefined && hidden === undefined && Object.keys(def).length === 0 && Object.keys(ns).length === 0 && barrel.value === undefined && barrel.hidden === undefined && Object.keys(barrel.ns).length === 0 && Object.keys(barrel.def).length === 0 && Object.keys(barrel).length === 4 && cjs.ok; ok;";
+ let script = module_script(
+ ModuleSource {
+ script: code,
+ original: code,
+ filename: "/src/entry.js",
+ },
+ &mut loader,
+ true,
+ )?;
+ let value = boa_engine::Context::default()
+ .eval(boa_engine::Source::from_bytes(&format!(
+ "const __vanilla_extract__ = {{ __at: (_location, _api, thunk) => thunk() }};\n{}{}",
+ loader.prelude(),
+ script.body
+ )))
+ .map_err(|error| error.to_string())?;
+ assert_eq!(value.as_boolean(), Some(true));
+ assert_eq!(
+ loader.dependencies,
+ BTreeSet::from(["/src/barrel.js".to_string(), "/src/cjs.js".to_string()])
+ );
+ assert_eq!(loader.kept_imports, Vec::::new());
+ Ok(())
+}
+
+#[test]
+fn ignored_named_when_key_is_inherited_is_undefined() -> Result<(), String> {
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ let option = ExtractOption::default();
+ for key in ["constructor", "toString", "__proto__", "hasOwnProperty"] {
+ let mut loader = ModuleLoader::new(Some(&resolver), &option);
+ let code =
+ format!("import {{ {key} as value }} from 'empty'; typeof value === 'undefined';");
+ let script = module_script(
+ ModuleSource {
+ script: &code,
+ original: &code,
+ filename: "/src/entry.js",
+ },
+ &mut loader,
+ true,
+ )?;
+ let value = boa_engine::Context::default()
+ .eval(boa_engine::Source::from_bytes(&format!(
+ "{}{}",
+ loader.prelude(),
+ script.body
+ )))
+ .map_err(|error| error.to_string())?;
+ assert_eq!(value.as_boolean(), Some(true), "{key}");
+ assert_eq!(loader.dependencies, BTreeSet::new());
+ }
+ Ok(())
+}
diff --git a/libs/extractor/src/ignored_module_tests.rs b/libs/extractor/src/ignored_module_tests.rs
new file mode 100644
index 000000000..84c1193fd
--- /dev/null
+++ b/libs/extractor/src/ignored_module_tests.rs
@@ -0,0 +1,254 @@
+use super::*;
+use serial_test::serial;
+
+#[test]
+#[serial]
+fn ignored_default_when_serialized_is_an_ordinary_empty_object() -> Result<(), String> {
+ let filename = "/src/ignored-literal.ts";
+ let allocator = Allocator::default();
+ let parsed = Parser::new(
+ &allocator,
+ "import ignored from 'empty';",
+ SourceType::from_path(filename).map_err(|error| error.to_string())?,
+ )
+ .parse();
+ assert_eq!(parsed.diagnostics.errors().count(), 0);
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ let option = ExtractOption::default();
+ let check =
+ imported_constants::ChangeCheck::new(&parsed.program, filename, &option, Some(&resolver));
+ let literal = check
+ .known("ignored")
+ .ok_or_else(|| "Ignored default import must have a known value".to_string())?;
+ let value = boa_engine::Context::default()
+ .eval(boa_engine::Source::from_bytes(&format!(
+ "const value = {literal}; Object.keys(value).length === 0 && Object.getPrototypeOf(value) === Object.prototype;"
+ )))
+ .map_err(|error| error.to_string())?;
+ assert_eq!(value.as_boolean(), Some(true));
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn ignored_object_when_spread_into_style_preserves_static_color() -> Result<(), Box> {
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ let output = extract_with_modules(
+ "/src/ignored-spread.ts",
+ "import {css} from '@devup-ui/react'; import ignored from 'empty'; const input = {...ignored, color: 'red'}; export const cls = css(input);",
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert_eq!(output.styles.len(), 1);
+ assert!(output.styles.iter().all(|style| matches!(
+ style, ExtractStyleValue::Static(style) if style.property == "color" && style.value == "red"
+ )));
+ assert!(!output.code.contains("css("), "{}", output.code);
+ assert_eq!(output.dependencies, Vec::::new());
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn ignored_object_when_used_as_style_extracts_empty_static_rules() -> Result<(), Box> {
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ let output = extract_with_modules(
+ "/src/ignored-style.ts",
+ "import {css} from '@devup-ui/react'; import ignored from 'empty'; export const cls = css(ignored);",
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert_eq!(output.styles.len(), 0, "{:?}", output.styles);
+ assert!(!output.code.contains("css("), "{}", output.code);
+ assert!(!output.code.contains("--"), "{}", output.code);
+ assert_eq!(output.dependencies, Vec::::new());
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn ignored_named_values_when_resolved_have_no_dynamic_style_or_dependency()
+-> Result<(), Box> {
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ for binding in [
+ "import { missing as value } from 'empty';",
+ "import * as ns from 'empty'; const value = ns.missing;",
+ "import def from 'empty'; const value = def.missing;",
+ ] {
+ let output = extract_with_modules(
+ "/src/ignored.tsx",
+ &format!(
+ "import {{Box}} from '@devup-ui/react'; {binding} export const view = ;"
+ ),
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert_eq!(output.dependencies, Vec::::new());
+ assert!(!output.code.contains("--"), "{}", output.code);
+ }
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn ignored_stylesheet_bindings_when_evaluated_are_empty_commonjs() -> Result<(), Box> {
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ let output = extract_with_modules(
+ "/src/ignored.css.ts",
+ "import {style} from '@devup-ui/react'; import def, {missing} from 'empty'; import * as ns from 'empty'; function color() { if (missing !== undefined || Object.keys(ns).length || Object.keys(def).length) throw new Error('bad interop'); return 'red'; } export const cls = style({color: color()});",
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert_eq!(output.dependencies, Vec::::new());
+ assert!(!output.code.contains("style("));
+ assert!(!output.code.contains("--"));
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn ignored_constants_when_required_or_reexported_remain_known() -> Result<(), Box> {
+ let resolver = |specifier: &str, _: &str| {
+ match specifier {
+ "empty" => Some(ModuleResolution::Ignored),
+ "barrel" => Some(ModuleResolution::Resolved(ResolvedModule {
+ path: "/src/barrel.js".to_string(),
+ code: "export {missing as value} from 'empty'; export * as ns from 'empty'; export * from 'empty';".to_string(),
+ source_type: None,
+ })),
+ "cjs" => Some(ModuleResolution::Resolved(ResolvedModule {
+ path: "/src/cjs.js".to_string(),
+ code: "module.exports = require('empty');".to_string(),
+ source_type: None,
+ })),
+ "cjsProps" => Some(ModuleResolution::Resolved(ResolvedModule {
+ path: "/src/cjsProps.js".to_string(),
+ code: "const {missing} = require('empty'); exports.value = missing; exports.other = require('empty').absent;".to_string(),
+ source_type: None,
+ })),
+ _ => None,
+ }
+ };
+ for (binding, dependencies) in [
+ ("import {value} from 'barrel';", vec!["/src/barrel.js"]),
+ (
+ "import {ns} from 'barrel'; const value = ns.missing;",
+ vec!["/src/barrel.js"],
+ ),
+ (
+ "import def from 'cjs'; const value = def.missing;",
+ vec!["/src/cjs.js"],
+ ),
+ ("import {value} from 'cjsProps';", vec!["/src/cjsProps.js"]),
+ (
+ "import {other as value} from 'cjsProps';",
+ vec!["/src/cjsProps.js"],
+ ),
+ ] {
+ let output = extract_with_modules(
+ "/src/entry.tsx",
+ &format!(
+ "import {{Box}} from '@devup-ui/react'; {binding} export const view = ;"
+ ),
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert_eq!(output.dependencies, dependencies);
+ assert!(!output.code.contains("--"), "{}", output.code);
+ }
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn ignored_object_when_mutated_is_not_inlined_as_empty() -> Result<(), Box> {
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ for binding in ["import def from 'empty';", "import * as def from 'empty';"] {
+ let output = extract_with_modules(
+ "/src/mutated.tsx",
+ &format!(
+ "import {{Box}} from '@devup-ui/react'; {binding} def.color = 'blue'; export const view = ;"
+ ),
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert!(output.code.contains("--"));
+ assert_eq!(output.dependencies, Vec::::new());
+ }
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn real_commonjs_when_empty_keeps_inherited_reads() -> Result<(), Box> {
+ let resolver = |_: &str, _: &str| {
+ Some(ModuleResolution::Resolved(ResolvedModule {
+ path: "/src/tokens.js".to_string(),
+ code: "module.exports = {};".to_string(),
+ source_type: None,
+ }))
+ };
+ let output = extract_with_modules(
+ "/src/real.tsx",
+ "import {Box} from '@devup-ui/react'; import def from 'tokens'; export const view = ;",
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert!(output.code.contains("def.constructor"), "{}", output.code);
+ assert_eq!(output.dependencies, vec!["/src/tokens.js"]);
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn ignored_missing_when_undefined_is_shadowed_keeps_primitive_argument()
+-> Result<(), Box> {
+ let resolver = |_: &str, _: &str| Some(ModuleResolution::Ignored);
+ let output = extract_with_modules(
+ "/src/shadowed.tsx",
+ "import {Box} from '@devup-ui/react'; import {missing} from 'empty'; export const View = (undefined, read) => ;",
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert!(output.code.contains("read(void 0)"), "{}", output.code);
+ assert_eq!(output.dependencies, Vec::::new());
+ Ok(())
+}
+
+#[test]
+#[serial]
+fn unresolved_require_when_dynamic_or_shadowed_is_not_an_ignored_constant()
+-> Result<(), Box> {
+ for code in [
+ "module.exports = require(name);",
+ "module.exports = require('missing');",
+ "const require = () => ({}); module.exports = require('empty');",
+ ] {
+ let resolver = |specifier: &str, _: &str| match specifier {
+ "tokens" => Some(ModuleResolution::Resolved(ResolvedModule {
+ path: "/src/tokens.js".to_string(),
+ code: code.to_string(),
+ source_type: None,
+ })),
+ "empty" => Some(ModuleResolution::Ignored),
+ _ => None,
+ };
+ let output = extract_with_modules(
+ "/src/unresolved.tsx",
+ "import {Box} from '@devup-ui/react'; import value from 'tokens'; export const view = ;",
+ ExtractOption::default(),
+ false,
+ &resolver,
+ )?;
+ assert!(output.code.contains("--"));
+ }
+ Ok(())
+}
diff --git a/libs/extractor/src/import_alias_scoping_tests.rs b/libs/extractor/src/import_alias_scoping_tests.rs
index fae3e4d79..a130b03f9 100644
--- a/libs/extractor/src/import_alias_scoping_tests.rs
+++ b/libs/extractor/src/import_alias_scoping_tests.rs
@@ -188,8 +188,13 @@ fn type_only_devup_components_do_not_take_css_props() {
#[test]
fn number_edits_map_back_to_original_offsets_when_imports_are_rewritten() {
let code = "import { css as c } from '@emotion/react';\nc({ top: 23 }); function local(c) { c({ top: 24 }); }";
- let output =
- transform_import_aliases_with_edits(code, "test.tsx", "@devup-ui/react", &aliases());
+ let output = transform_import_aliases_with_edits(
+ code,
+ "test.tsx",
+ "@devup-ui/react",
+ &aliases(),
+ oxc_span::SourceType::tsx(),
+ );
let Some(pixel) = output.code.find("\"23px\"") else {
panic!("missing pixelified number: {}", output.code);
};
diff --git a/libs/extractor/src/import_alias_visit.rs b/libs/extractor/src/import_alias_visit.rs
index 942e193b3..158e11183 100644
--- a/libs/extractor/src/import_alias_visit.rs
+++ b/libs/extractor/src/import_alias_visit.rs
@@ -28,9 +28,7 @@ use oxc_ast_visit::{
};
use oxc_parser::Parser;
use oxc_semantic::{Scoping, SemanticBuilder};
-use oxc_span::GetSpan;
-#[cfg(test)]
-use oxc_span::SourceType;
+use oxc_span::{GetSpan, SourceType};
use oxc_syntax::symbol::SymbolId;
use std::borrow::Cow;
use std::collections::HashMap;
@@ -475,7 +473,14 @@ pub fn transform_import_aliases<'a>(
package: &str,
import_aliases: &HashMap,
) -> Cow<'a, str> {
- transform_import_aliases_with_edits(code, filename, package, import_aliases).code
+ transform_import_aliases_with_edits(
+ code,
+ filename,
+ package,
+ import_aliases,
+ crate::parser_source_type(filename).unwrap_or_default(),
+ )
+ .code
}
/// What rewriting aliased imports gives
@@ -505,7 +510,7 @@ const VANILLA_EXTRACT_COMPANIONS: [&str; 2] =
/// The value imports of vanilla-extract's companion packages, as errors at
/// their offsets: while `@vanilla-extract/css` compiles to Devup UI, the
/// rules they generate would never reach the stylesheet
-pub fn companion_errors(code: &str, filename: &str) -> Vec<(u32, String)> {
+pub fn companion_errors(code: &str, source_type: SourceType) -> Vec<(u32, String)> {
if !VANILLA_EXTRACT_COMPANIONS
.iter()
.any(|package| code.contains(package))
@@ -513,7 +518,6 @@ pub fn companion_errors(code: &str, filename: &str) -> Vec<(u32, String)> {
return Vec::new();
}
let allocator = Allocator::default();
- let source_type = crate::parsing::source_type(filename).unwrap_or_default();
let program = Parser::new(&allocator, code, source_type).parse().program;
program
.body
@@ -556,6 +560,7 @@ pub fn transform_import_aliases_with_edits<'a>(
filename: &str,
package: &str,
import_aliases: &HashMap,
+ source_type: oxc_span::SourceType,
) -> Aliased<'a> {
let unchanged = |css_prop, px| Aliased {
code: Cow::Borrowed(code),
@@ -575,7 +580,6 @@ pub fn transform_import_aliases_with_edits<'a>(
}
let allocator = Allocator::default();
- let source_type = crate::parsing::source_type(filename).unwrap_or_default();
// Parse the code
let parser_ret = Parser::new(&allocator, code, source_type).parse();
@@ -786,11 +790,10 @@ pub fn transform_import_aliases_with_edits<'a>(
/// Reapply Emotion units to literals produced after the initial alias pass.
pub(super) fn pixelify_emotion_values<'a>(
code: &'a str,
- filename: &str,
+ source_type: SourceType,
original: &str,
) -> (Cow<'a, str>, Vec) {
let allocator = Allocator::default();
- let source_type = crate::parsing::source_type(filename).unwrap_or_default();
let original_program = Parser::new(&allocator, original, source_type)
.parse()
.program;
@@ -1124,7 +1127,7 @@ mod tests {
use super::*;
use insta::assert_snapshot;
use oxc_ast::builder::AstBuilder;
- use oxc_span::SPAN;
+ use oxc_span::{SPAN, SourceType};
fn emotion_alias() -> HashMap {
let mut aliases = HashMap::new();
@@ -1351,7 +1354,7 @@ css({ background: ['red', 'linear-gradient(red, blue)'], WebkitBoxShadow: ['none
import { recipe } from '@vanilla-extract/recipes'
import { style } from '@vanilla-extract/css'
import { createSprinkles } from '@vanilla-extract/sprinkles'",
- "a.css.ts",
+ SourceType::ts(),
);
assert_eq!(errors.len(), 2, "{errors:?}");
assert!(
@@ -1365,11 +1368,30 @@ import { createSprinkles } from '@vanilla-extract/sprinkles'",
.starts_with("`@vanilla-extract/sprinkles` generates CSS")
);
assert_eq!(
- companion_errors("import { style } from '@vanilla-extract/css'", "a.css.ts"),
+ companion_errors(
+ "import { style } from '@vanilla-extract/css'",
+ SourceType::ts()
+ ),
vec![]
);
}
+ #[test]
+ fn companions_after_jsx_are_reported_when_the_effective_grammar_is_compiled_output() {
+ // Given: compiler output whose JSX precedes a companion import.
+ let source = "export const view=;\nimport {recipe} from '@vanilla-extract/recipes';";
+ // When: companion detection receives the selected JSX grammar.
+ let errors = companion_errors(source, SourceType::jsx());
+ // Then: the diagnostic points to the authored import rather than skipping it.
+ assert_eq!(errors.len(), 1);
+ assert_eq!(
+ usize::try_from(errors[0].0).unwrap_or_else(|error| panic!("{error}")),
+ source
+ .find("import ")
+ .unwrap_or_else(|| panic!("missing companion import")),
+ );
+ }
+
#[test]
fn test_emotion_cache_provider_redirects_to_compat() {
let code = transform_import_aliases(
@@ -1747,6 +1769,7 @@ const x = 1;",
"styles.css.ts",
"@devup-ui/react",
&aliases,
+ SourceType::ts(),
);
let allocator = Allocator::default();
let parsed = Parser::new(&allocator, &output.code, SourceType::ts()).parse();
@@ -1769,8 +1792,13 @@ const x = 1;",
fn unmatched_surrogate_source_keeps_original_import() {
let source = r"import { css } from '\uD800'; // source";
let aliases = HashMap::from([("source".to_string(), ImportAlias::NamedToNamed)]);
- let output =
- transform_import_aliases_with_edits(source, "view.ts", "@devup-ui/react", &aliases);
+ let output = transform_import_aliases_with_edits(
+ source,
+ "view.ts",
+ "@devup-ui/react",
+ &aliases,
+ SourceType::ts(),
+ );
assert_eq!(output.code, source);
assert_eq!(output.edits.len(), 0);
}
@@ -1794,7 +1822,13 @@ const x = 1;",
.iter()
.map(|code| {
let aliased =
- transform_import_aliases_with_edits(code, "test.tsx", "@devup-ui/react", &aliases);
+ transform_import_aliases_with_edits(
+ code,
+ "test.tsx",
+ "@devup-ui/react",
+ &aliases,
+ oxc_span::SourceType::tsx(),
+ );
(aliased.code.into_owned(), aliased.css_prop)
})
.collect();
@@ -1805,6 +1839,7 @@ const x = 1;",
"test.tsx",
"@devup-ui/react",
&emotion_alias(),
+ oxc_span::SourceType::tsx(),
);
assert_eq!(without_css_prop.css_prop, CssProp::Off);
assert!(matches!(without_css_prop.code, Cow::Borrowed(_)));
@@ -1838,7 +1873,13 @@ const x = 1;",
.iter()
.map(|(filename, code)| {
let aliased =
- transform_import_aliases_with_edits(code, filename, "@devup-ui/react", &aliases);
+ transform_import_aliases_with_edits(
+ code,
+ filename,
+ "@devup-ui/react",
+ &aliases,
+ crate::parser_source_type(filename).unwrap_or_default(),
+ );
(aliased.code.into_owned(), aliased.css_prop, aliased.edits)
})
.collect();
@@ -1852,6 +1893,7 @@ const x = 1;",
crate::css_prop::EMOTION_JSX_RUNTIME.to_string(),
ImportAlias::NamedToNamed,
)]),
+ oxc_span::SourceType::tsx(),
);
assert_eq!(runtime_alone.css_prop, CssProp::Off);
assert!(matches!(runtime_alone.code, Cow::Borrowed(_)));
diff --git a/libs/extractor/src/imported_constants.rs b/libs/extractor/src/imported_constants.rs
index 2a1cdc0bd..610fd73b4 100644
--- a/libs/extractor/src/imported_constants.rs
+++ b/libs/extractor/src/imported_constants.rs
@@ -16,7 +16,12 @@ use oxc_ast::builder::AstBuilder;
use oxc_ast_visit::{Visit, VisitMut, walk, walk_mut};
use oxc_parser::Parser;
use oxc_semantic::{Scoping, SemanticBuilder};
-use oxc_span::{GetSpan, SPAN, SourceType};
+#[cfg(test)]
+use oxc_span::SourceType;
+use oxc_span::{GetSpan, SPAN};
+#[cfg(test)]
+#[path = "imported_source_type_tests.rs"]
+mod source_type_tests;
use oxc_syntax::number::NumberBase;
use oxc_syntax::operator::BinaryOperator;
use oxc_syntax::symbol::SymbolId;
@@ -26,7 +31,10 @@ use crate::composition::{Composition, set_prop_order};
use crate::css_prop::{CssProp, CssTakers, binding_of, reads_top_level, root_reference};
use crate::extractor::extract_style_from_expression::LiteralHandling;
use crate::stylex::StylexFunction;
-use crate::{ExtractOption, ExtractStyleValue, ModuleResolver};
+use crate::{ExtractOption, ExtractStyleValue, ModuleResolution, ModuleResolver};
+
+mod exports;
+use exports::Exports;
#[cfg(test)]
#[path = "local_capture_coverage_tests.rs"]
@@ -60,6 +68,8 @@ enum Constant {
Object(Rc>),
/// An object literal every property of which is known, in source order
Record(Rc>),
+ /// An ignored module's empty `CommonJS` object, with ordinary prototype reads
+ IgnoredObject,
Array(Rc>),
/// `StyleX` custom properties by key, which read as their `var()`
Vars(Rc>),
@@ -115,6 +125,7 @@ impl Constant {
| Self::Null
| Self::Bool(_)
| Self::Undefined
+ | Self::IgnoredObject
| Self::Function
| Self::Vars(_)
| Self::Theme(_)
@@ -124,7 +135,10 @@ impl Constant {
}
/// Whether code can change what it holds
const fn is_mutable(&self) -> bool {
- matches!(self, Self::Object(_) | Self::Record(_) | Self::Array(_))
+ matches!(
+ self,
+ Self::Object(_) | Self::Record(_) | Self::IgnoredObject | Self::Array(_)
+ )
}
/// Whether this value or one it holds is a function
@@ -145,7 +159,8 @@ impl Constant {
Self::Number(number) => Some(crate::utils::js_number_string(*number)),
Self::Null => Some("null".to_string()),
Self::Bool(value) => Some(value.to_string()),
- Self::Undefined => Some("undefined".to_string()),
+ Self::Undefined => Some("(void 0)".to_string()),
+ Self::IgnoredObject => Some("({})".to_string()),
Self::Record(entries) => {
let mut properties = Vec::with_capacity(entries.len());
for (key, value) in entries.iter() {
@@ -815,7 +830,11 @@ fn inline_in<'a>(
.visit_program(program);
reads_math
};
- inlined.dependencies = modules.exports.into_keys().collect();
+ inlined.dependencies = modules
+ .exports
+ .into_keys()
+ .map(|(path, _, _)| path)
+ .collect();
let callbacks = bound_style_callbacks::rewrite(ast_builder, program, scoping, &option.package);
inlined.errors.extend(callbacks.errors);
let mut captures = callbacks.captures;
@@ -965,7 +984,12 @@ impl<'p, 'a, 'r> ChangeCheck<'p, 'a, 'r> {
/// The modules read for the values of imports
pub(crate) fn dependencies(&self) -> BTreeSet {
- self.modules.borrow().exports.keys().cloned().collect()
+ self.modules
+ .borrow()
+ .exports
+ .keys()
+ .map(|(path, _, _)| path.clone())
+ .collect()
}
pub(crate) fn is_changed(&self, name: &str) -> bool {
@@ -1229,46 +1253,50 @@ pub(crate) fn jsx_root<'n>(name: &'n JSXElementName<'_>) -> Option<&'n str> {
/// The constant exports of the modules read, by path
struct Modules<'r> {
- resolver: Option<&'r ModuleResolver>,
+ resolver: Option<&'r ModuleResolver<'r>>,
option: &'r ExtractOption,
- exports: FxHashMap>>,
+ exports: FxHashMap>>,
loading: Vec,
}
impl Modules<'_> {
- fn exports(
- &mut self,
- specifier: &str,
- importer: &str,
- ) -> Option