diff --git a/crates/cfg/Cargo.toml b/crates/cfg/Cargo.toml index fbda065b10..059fd85440 100644 --- a/crates/cfg/Cargo.toml +++ b/crates/cfg/Cargo.toml @@ -16,6 +16,7 @@ rustc-hash.workspace = true # locals deps tt.workspace = true +syntax.workspace = true [dev-dependencies] expect-test = "1.4.1" @@ -28,7 +29,6 @@ derive_arbitrary = "1.3.2" # local deps mbe.workspace = true -syntax.workspace = true [lints] -workspace = true \ No newline at end of file +workspace = true diff --git a/crates/cfg/src/cfg_attr.rs b/crates/cfg/src/cfg_attr.rs deleted file mode 100644 index 4eb5928b1e..0000000000 --- a/crates/cfg/src/cfg_attr.rs +++ /dev/null @@ -1,70 +0,0 @@ -use std::{ - fmt::{self, Debug}, - slice::Iter as SliceIter, -}; - -use crate::{cfg_expr::next_cfg_expr, CfgAtom, CfgExpr}; -use tt::{Delimiter, SmolStr, Span}; -/// Represents a `#[cfg_attr(.., my_attr)]` attribute. -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CfgAttr { - /// Expression in `cfg_attr` attribute. - pub cfg_expr: CfgExpr, - /// Inner attribute. - pub attr: tt::Subtree, -} - -impl CfgAttr { - /// Parses a sub tree in the form of (cfg_expr, inner_attribute) - pub fn parse(tt: &tt::Subtree) -> Option> { - let mut iter = tt.token_trees.iter(); - let cfg_expr = next_cfg_expr(&mut iter).unwrap_or(CfgExpr::Invalid); - // FIXME: This is probably not the right way to do this - // Get's the span of the next token tree - let first_span = iter.as_slice().first().map(|tt| tt.first_span())?; - let attr = tt::Subtree { - delimiter: Delimiter::invisible_spanned(first_span), - token_trees: iter.cloned().collect(), - }; - Some(CfgAttr { cfg_expr, attr: attr }) - } -} - -#[cfg(test)] -mod tests { - use expect_test::{expect, Expect}; - use mbe::{syntax_node_to_token_tree, DummyTestSpanMap, DUMMY}; - use syntax::{ast, AstNode}; - - use crate::{CfgAttr, DnfExpr}; - - fn check_dnf(input: &str, expected_dnf: Expect, expected_attrs: Expect) { - let source_file = ast::SourceFile::parse(input).ok().unwrap(); - let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap(); - let tt = syntax_node_to_token_tree(tt.syntax(), DummyTestSpanMap, DUMMY); - let Some(CfgAttr { cfg_expr, attr }) = CfgAttr::parse(&tt) else { - assert!(false, "failed to parse cfg_attr"); - return; - }; - - let actual = format!("#![cfg({})]", DnfExpr::new(cfg_expr)); - expected_dnf.assert_eq(&actual); - let actual_attrs = format!("#![{}]", attr); - expected_attrs.assert_eq(&actual_attrs); - } - - #[test] - fn smoke() { - check_dnf( - r#"#![cfg_attr(feature = "nightly", feature(slice_split_at_unchecked))]"#, - expect![[r#"#![cfg(feature = "nightly")]"#]], - expect![r#"#![feature (slice_split_at_unchecked)]"#], - ); - - check_dnf( - r#"#![cfg_attr(not(feature = "std"), no_std)]"#, - expect![[r#"#![cfg(not(feature = "std"))]"#]], - expect![r#"#![no_std]"#], - ); - } -} diff --git a/crates/cfg/src/cfg_expr.rs b/crates/cfg/src/cfg_expr.rs index 425fa90efe..91731c29d2 100644 --- a/crates/cfg/src/cfg_expr.rs +++ b/crates/cfg/src/cfg_expr.rs @@ -2,8 +2,12 @@ //! //! See: -use std::{fmt, slice::Iter as SliceIter}; +use std::{fmt, iter::Peekable, slice::Iter as SliceIter}; +use syntax::{ + ast::{self, Meta}, + NodeOrToken, +}; use tt::SmolStr; /// A simple configuration value passed in from the outside. @@ -47,6 +51,12 @@ impl CfgExpr { pub fn parse(tt: &tt::Subtree) -> CfgExpr { next_cfg_expr(&mut tt.token_trees.iter()).unwrap_or(CfgExpr::Invalid) } + /// Parses a `cfg` attribute from the meta + pub fn parse_from_attr_meta(meta: Meta) -> Option { + let tt = meta.token_tree()?; + let mut iter = tt.token_trees_and_tokens().skip(1).peekable(); + next_cfg_expr_from_syntax(&mut iter) + } /// Fold the cfg by querying all basic `Atom` and `KeyValue` predicates. pub fn fold(&self, query: &dyn Fn(&CfgAtom) -> bool) -> Option { match self { @@ -62,8 +72,71 @@ impl CfgExpr { } } } +fn next_cfg_expr_from_syntax(iter: &mut Peekable) -> Option +where + I: Iterator>, +{ + let name = match iter.next() { + None => return None, + Some(NodeOrToken::Token(element)) => match element.kind() { + syntax::T![ident] => SmolStr::new(element.text()), + _ => return Some(CfgExpr::Invalid), + }, + Some(_) => return Some(CfgExpr::Invalid), + }; + let result = match name.as_str() { + "all" | "any" | "not" => { + let mut preds = Vec::new(); + let Some(NodeOrToken::Node(tree)) = iter.next() else { + return Some(CfgExpr::Invalid); + }; + let mut tree_iter = tree.token_trees_and_tokens().skip(1).peekable(); + while tree_iter + .peek() + .filter( + |element| matches!(element, NodeOrToken::Token(token) if (token.kind() != syntax::T![')'])), + ) + .is_some() + { + let pred = next_cfg_expr_from_syntax(&mut tree_iter); + if let Some(pred) = pred { + preds.push(pred); + } + } + let group = match name.as_str() { + "all" => CfgExpr::All(preds), + "any" => CfgExpr::Any(preds), + "not" => CfgExpr::Not(Box::new(preds.pop().unwrap_or(CfgExpr::Invalid))), + _ => unreachable!(), + }; + Some(group) + } + _ => match iter.peek() { + Some(NodeOrToken::Token(element)) if (element.kind() == syntax::T![=]) => { + iter.next(); + match iter.next() { + Some(NodeOrToken::Token(value_token)) + if (value_token.kind() == syntax::SyntaxKind::STRING) => + { + let value = value_token.text(); + let value = SmolStr::new(value.trim_matches('"')); + Some(CfgExpr::Atom(CfgAtom::KeyValue { key: name, value })) + } + _ => None, + } + } + _ => Some(CfgExpr::Atom(CfgAtom::Flag(name))), + }, + }; + if let Some(NodeOrToken::Token(element)) = iter.peek() { + if element.kind() == syntax::T![,] { + iter.next(); + } + } + result +} -pub(crate) fn next_cfg_expr(it: &mut SliceIter<'_, tt::TokenTree>) -> Option { +fn next_cfg_expr(it: &mut SliceIter<'_, tt::TokenTree>) -> Option { let name = match it.next() { None => return None, Some(tt::TokenTree::Leaf(tt::Leaf::Ident(ident))) => ident.text.clone(), diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs index 4d5483d956..454d6fc538 100644 --- a/crates/cfg/src/lib.rs +++ b/crates/cfg/src/lib.rs @@ -2,8 +2,7 @@ #![warn(rust_2018_idioms, unused_lifetimes)] -mod cfg_attr; -pub(crate) mod cfg_expr; +mod cfg_expr; mod dnf; #[cfg(test)] mod tests; @@ -13,7 +12,6 @@ use std::fmt; use rustc_hash::FxHashSet; use tt::SmolStr; -pub use cfg_attr::CfgAttr; pub use cfg_expr::{CfgAtom, CfgExpr}; pub use dnf::DnfExpr; diff --git a/crates/cfg/src/tests.rs b/crates/cfg/src/tests.rs index 62fb429a63..8eca907d8b 100644 --- a/crates/cfg/src/tests.rs +++ b/crates/cfg/src/tests.rs @@ -1,7 +1,10 @@ use arbitrary::{Arbitrary, Unstructured}; use expect_test::{expect, Expect}; use mbe::{syntax_node_to_token_tree, DummyTestSpanMap, DUMMY}; -use syntax::{ast, AstNode}; +use syntax::{ + ast::{self, Attr}, + AstNode, SourceFile, +}; use crate::{CfgAtom, CfgExpr, CfgOptions, DnfExpr}; @@ -12,6 +15,22 @@ fn assert_parse_result(input: &str, expected: CfgExpr) { let cfg = CfgExpr::parse(&tt); assert_eq!(cfg, expected); } +fn check_dnf_from_syntax(input: &str, expect: Expect) { + let parse = SourceFile::parse(input); + let node = match parse.tree().syntax().descendants().find_map(Attr::cast) { + Some(it) => it, + None => { + let node = std::any::type_name::(); + panic!("Failed to make ast node `{node}` from text {input}") + } + }; + let node = node.clone_subtree(); + assert_eq!(node.syntax().text_range().start(), 0.into()); + + let cfg = CfgExpr::parse_from_attr_meta(node.meta().unwrap()).unwrap(); + let actual = format!("#![cfg({})]", DnfExpr::new(cfg)); + expect.assert_eq(&actual); +} fn check_dnf(input: &str, expect: Expect) { let source_file = ast::SourceFile::parse(input).ok().unwrap(); @@ -86,6 +105,11 @@ fn smoke() { check_dnf("#![cfg(not(a))]", expect![[r#"#![cfg(not(a))]"#]]); } +#[test] +fn cfg_from_attr() { + check_dnf_from_syntax(r#"#[cfg(test)]"#, expect![[r#"#![cfg(test)]"#]]); + check_dnf_from_syntax(r#"#[cfg(not(never))]"#, expect![[r#"#![cfg(not(never))]"#]]); +} #[test] fn distribute() { diff --git a/crates/hir-expand/src/cfg_process.rs b/crates/hir-expand/src/cfg_process.rs index 7f6158f6bb..d67402b0b8 100644 --- a/crates/hir-expand/src/cfg_process.rs +++ b/crates/hir-expand/src/cfg_process.rs @@ -1,102 +1,65 @@ -use std::os::windows::process; - -use mbe::syntax_node_to_token_tree; +//! Processes out #[cfg] and #[cfg_attr] attributes from the input for the derive macro use rustc_hash::FxHashSet; use syntax::{ - ast::{self, Attr, FieldList, HasAttrs, RecordFieldList, TupleFieldList, Variant, VariantList}, + ast::{self, Attr, HasAttrs, Meta, VariantList}, AstNode, SyntaxElement, SyntaxNode, T, }; -use tracing::info; +use tracing::{info, warn}; -use crate::{db::ExpandDatabase, span_map::SpanMap, MacroCallLoc}; +use crate::{db::ExpandDatabase, MacroCallKind, MacroCallLoc}; -fn check_cfg_attr( - attr: &Attr, - loc: &MacroCallLoc, - span_map: &SpanMap, - db: &dyn ExpandDatabase, -) -> Option { - attr.simple_name().as_deref().map(|v| v == "cfg")?; - info!("Checking cfg attr {:?}", attr); - let Some(tt) = attr.token_tree() else { - info!("cfg attr has no expr {:?}", attr); - return Some(true); - }; - info!("Checking cfg {:?}", tt); - let tt = tt.syntax().clone(); - // Convert to a tt::Subtree - let tt = syntax_node_to_token_tree(&tt, span_map, loc.call_site); - let cfg = cfg::CfgExpr::parse(&tt); +fn check_cfg_attr(attr: &Attr, loc: &MacroCallLoc, db: &dyn ExpandDatabase) -> Option { + if !attr.simple_name().as_deref().map(|v| v == "cfg")? { + return None; + } + info!("Evaluating cfg {}", attr); + let cfg = cfg::CfgExpr::parse_from_attr_meta(attr.meta()?)?; + info!("Checking cfg {:?}", cfg); let enabled = db.crate_graph()[loc.krate].cfg_options.check(&cfg) != Some(false); Some(enabled) } -enum CfgAttrResult { - Enabled(Attr), - Disabled, -} -fn check_cfg_attr_attr( - attr: &Attr, - loc: &MacroCallLoc, - span_map: &SpanMap, - db: &dyn ExpandDatabase, -) -> Option { - attr.simple_name().as_deref().map(|v| v == "cfg_attr")?; - info!("Checking cfg_attr attr {:?}", attr); - let Some(tt) = attr.token_tree() else { - info!("cfg_attr attr has no expr {:?}", attr); +fn check_cfg_attr_attr(attr: &Attr, loc: &MacroCallLoc, db: &dyn ExpandDatabase) -> Option { + if !attr.simple_name().as_deref().map(|v| v == "cfg_attr")? { return None; - }; - info!("Checking cfg_attr {:?}", tt); - let tt = tt.syntax().clone(); - // Convert to a tt::Subtree - let tt = syntax_node_to_token_tree(&tt, span_map, loc.call_site); - let cfg = cfg::CfgExpr::parse(&tt); - let enabled = db.crate_graph()[loc.krate].cfg_options.check(&cfg) != Some(false); - if enabled { - // FIXME: Add the internal attribute - Some(CfgAttrResult::Enabled(attr.clone())) - } else { - Some(CfgAttrResult::Disabled) } + info!("Evaluating cfg_attr {}", attr); + + let cfg_expr = cfg::CfgExpr::parse_from_attr_meta(attr.meta()?)?; + info!("Checking cfg_attr {:?}", cfg_expr); + let enabled = db.crate_graph()[loc.krate].cfg_options.check(&cfg_expr) != Some(false); + Some(enabled) } fn process_has_attrs_with_possible_comma( items: impl Iterator, loc: &MacroCallLoc, - span_map: &SpanMap, db: &dyn ExpandDatabase, - res: &mut FxHashSet, + remove: &mut FxHashSet, ) -> Option<()> { for item in items { let field_attrs = item.attrs(); 'attrs: for attr in field_attrs { - let Some(enabled) = check_cfg_attr(&attr, loc, span_map, db) else { - continue; - }; - if enabled { - //FIXME: Should we remove the cfg_attr? - } else { - info!("censoring type {:?}", item.syntax()); - res.insert(item.syntax().clone().into()); - // We need to remove the , as well - if let Some(comma) = item.syntax().next_sibling_or_token() { - if comma.kind() == T![,] { - res.insert(comma.into()); - } - } - break 'attrs; - } - let Some(attr_result) = check_cfg_attr_attr(&attr, loc, span_map, db) else { - continue; - }; - match attr_result { - CfgAttrResult::Enabled(attr) => { - //FIXME: Replace the attribute with the internal attribute - } - CfgAttrResult::Disabled => { + if let Some(enabled) = check_cfg_attr(&attr, loc, db) { + // Rustc does not strip the attribute if it is enabled. So we will will leave it + if !enabled { info!("censoring type {:?}", item.syntax()); - res.insert(attr.syntax().clone().into()); + remove.insert(item.syntax().clone().into()); + // We need to remove the , as well + add_comma(&item, remove); + break 'attrs; + } + }; + + if let Some(enabled) = check_cfg_attr_attr(&attr, loc, db) { + if enabled { + info!("Removing cfg_attr tokens {:?}", attr); + let meta = attr.meta()?; + let removes_from_cfg_attr = remove_tokens_within_cfg_attr(meta)?; + remove.extend(removes_from_cfg_attr); + } else { + info!("censoring type cfg_attr {:?}", item.syntax()); + remove.insert(attr.syntax().clone().into()); continue; } } @@ -104,75 +67,130 @@ fn process_has_attrs_with_possible_comma( } Some(()) } + +fn remove_tokens_within_cfg_attr(meta: Meta) -> Option> { + let mut remove: FxHashSet = FxHashSet::default(); + info!("Enabling attribute {}", meta); + let meta_path = meta.path()?; + info!("Removing {:?}", meta_path.syntax()); + remove.insert(meta_path.syntax().clone().into()); + + let meta_tt = meta.token_tree()?; + info!("meta_tt {}", meta_tt); + // Remove the left paren + remove.insert(meta_tt.l_paren_token()?.into()); + let mut found_comma = false; + for tt in meta_tt.token_trees_and_tokens().skip(1) { + info!("Checking {:?}", tt); + // Check if it is a subtree or a token. If it is a token check if it is a comma. If so, remove it and break. + match tt { + syntax::NodeOrToken::Node(node) => { + // Remove the entire subtree + remove.insert(node.syntax().clone().into()); + } + syntax::NodeOrToken::Token(token) => { + if token.kind() == T![,] { + found_comma = true; + remove.insert(token.into()); + break; + } + remove.insert(token.into()); + } + } + } + if !found_comma { + warn!("No comma found in {}", meta_tt); + return None; + } + // Remove the right paren + remove.insert(meta_tt.r_paren_token()?.into()); + Some(remove) +} +fn add_comma(item: &impl AstNode, res: &mut FxHashSet) { + if let Some(comma) = item.syntax().next_sibling_or_token().filter(|it| it.kind() == T![,]) { + res.insert(comma); + } +} fn process_enum( variants: VariantList, loc: &MacroCallLoc, - span_map: &SpanMap, db: &dyn ExpandDatabase, - res: &mut FxHashSet, + remove: &mut FxHashSet, ) -> Option<()> { - for variant in variants.variants() { - 'attrs: for attr in variant.attrs() { - if !check_cfg_attr(&attr, loc, span_map, db)? { - info!("censoring variant {:?}", variant.syntax()); - res.insert(variant.syntax().clone().into()); - if let Some(comma) = variant.syntax().next_sibling_or_token() { - if comma.kind() == T![,] { - res.insert(comma.into()); - } + 'variant: for variant in variants.variants() { + for attr in variant.attrs() { + if let Some(enabled) = check_cfg_attr(&attr, loc, db) { + // Rustc does not strip the attribute if it is enabled. So we will will leave it + if !enabled { + info!("censoring type {:?}", variant.syntax()); + remove.insert(variant.syntax().clone().into()); + // We need to remove the , as well + add_comma(&variant, remove); + continue 'variant; + } + }; + + if let Some(enabled) = check_cfg_attr_attr(&attr, loc, db) { + if enabled { + info!("Removing cfg_attr tokens {:?}", attr); + let meta = attr.meta()?; + let removes_from_cfg_attr = remove_tokens_within_cfg_attr(meta)?; + remove.extend(removes_from_cfg_attr); + } else { + info!("censoring type cfg_attr {:?}", variant.syntax()); + remove.insert(attr.syntax().clone().into()); + continue; } - break 'attrs; } } if let Some(fields) = variant.field_list() { match fields { ast::FieldList::RecordFieldList(fields) => { - process_has_attrs_with_possible_comma(fields.fields(), loc, span_map, db, res)?; + process_has_attrs_with_possible_comma(fields.fields(), loc, db, remove)?; } ast::FieldList::TupleFieldList(fields) => { - process_has_attrs_with_possible_comma(fields.fields(), loc, span_map, db, res)?; + process_has_attrs_with_possible_comma(fields.fields(), loc, db, remove)?; } } } } Some(()) } -/// Handle + pub(crate) fn process_cfg_attrs( node: &SyntaxNode, loc: &MacroCallLoc, - span_map: &SpanMap, db: &dyn ExpandDatabase, ) -> Option> { + // FIXME: #[cfg_eval] is not implemented. But it is not stable yet + if !matches!(loc.kind, MacroCallKind::Derive { .. }) { + return None; + } let mut res = FxHashSet::default(); + let item = ast::Item::cast(node.clone())?; match item { ast::Item::Struct(it) => match it.field_list()? { ast::FieldList::RecordFieldList(fields) => { - process_has_attrs_with_possible_comma( - fields.fields(), - loc, - span_map, - db, - &mut res, - )?; + process_has_attrs_with_possible_comma(fields.fields(), loc, db, &mut res)?; } ast::FieldList::TupleFieldList(fields) => { - process_has_attrs_with_possible_comma( - fields.fields(), - loc, - span_map, - db, - &mut res, - )?; + process_has_attrs_with_possible_comma(fields.fields(), loc, db, &mut res)?; } }, ast::Item::Enum(it) => { - process_enum(it.variant_list()?, loc, span_map, db, &mut res)?; + process_enum(it.variant_list()?, loc, db, &mut res)?; } - // FIXME: Implement for other items + ast::Item::Union(it) => { + process_has_attrs_with_possible_comma( + it.record_field_list()?.fields(), + loc, + db, + &mut res, + )?; + } + // FIXME: Implement for other items if necessary. As we do not support #[cfg_eval] yet, we do not need to implement it for now _ => {} } - Some(res) } diff --git a/crates/hir-expand/src/db.rs b/crates/hir-expand/src/db.rs index 5188d80732..bb69c72be4 100644 --- a/crates/hir-expand/src/db.rs +++ b/crates/hir-expand/src/db.rs @@ -7,10 +7,9 @@ use mbe::{syntax_node_to_token_tree, ValueResult}; use rustc_hash::FxHashSet; use span::{AstIdMap, SyntaxContextData, SyntaxContextId}; use syntax::{ - ast::{self, Attr, HasAttrs}, + ast::{self, HasAttrs}, AstNode, Parse, SyntaxElement, SyntaxError, SyntaxNode, SyntaxToken, T, }; -use tracing::info; use triomphe::Arc; use crate::{ @@ -410,7 +409,8 @@ fn macro_arg( ), MacroCallKind::Derive { .. } | MacroCallKind::Attr { .. } => { let censor = censor_for_macro_input(&loc, &syntax); - let censor_cfg = censor_cfg_elements(&syntax, &loc, &map, db); + let censor_cfg = + cfg_process::process_cfg_attrs(&syntax, &loc, db).unwrap_or_default(); let mut fixups = fixup::fixup_syntax(map.as_ref(), &syntax, loc.call_site); fixups.append.retain(|it, _| match it { syntax::NodeOrToken::Token(_) => true, @@ -461,14 +461,7 @@ fn macro_arg( } } } -fn censor_cfg_elements( - node: &SyntaxNode, - loc: &MacroCallLoc, - span_map: &SpanMap, - db: &dyn ExpandDatabase, -) -> FxHashSet { - cfg_process::process_cfg_attrs(node, loc, span_map, db).unwrap_or_default() -} + // FIXME: Censoring info should be calculated by the caller! Namely by name resolution /// Certain macro calls expect some nodes in the input to be preprocessed away, namely: /// - derives expect all `#[derive(..)]` invocations up to the currently invoked one to be stripped diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs index 593a8e5ed3..972e548d34 100644 --- a/crates/mbe/src/syntax_bridge.rs +++ b/crates/mbe/src/syntax_bridge.rs @@ -9,7 +9,6 @@ use syntax::{ SyntaxKind::*, SyntaxNode, SyntaxToken, SyntaxTreeBuilder, TextRange, TextSize, WalkEvent, T, }; -use tracing::info; use tt::{ buffer::{Cursor, TokenBuffer}, Span,