internal: Thread edition through to parsing/tt-to-syntax-tree routines for macros

Author: Veykril

crates/base-db/src/lib.rs

@@ -83,7 +83,8 @@ fn toolchain_channel(db: &dyn SourceDatabase, krate: CrateId) -> Option<ReleaseC
 fnparse(db:&dynSourceDatabase,file_id:FileId) -> Parse<ast::SourceFile>{
 let _p = tracing::span!(tracing::Level::INFO,"parse_query", ?file_id).entered();
 let text = db.file_text(file_id);
-SourceFile::parse(&text)
+// FIXME: Edition based parsing
+SourceFile::parse(&text, span::Edition::CURRENT)
 }
 
 /// We don't want to give HIR knowledge of source roots, hence we extract these

crates/cfg/src/tests.rs

@@ -1,20 +1,20 @@
 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,AstNode,Edition};
 
 usecrate::{CfgAtom,CfgExpr,CfgOptions,DnfExpr};
 
 fnassert_parse_result(input:&str,expected:CfgExpr){
-let source_file = ast::SourceFile::parse(input).ok().unwrap();
+let source_file = ast::SourceFile::parse(input,Edition::CURRENT).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 cfg = CfgExpr::parse(&tt);
 assert_eq!(cfg, expected);
 }
 
 fncheck_dnf(input:&str,expect:Expect){
-let source_file = ast::SourceFile::parse(input).ok().unwrap();
+let source_file = ast::SourceFile::parse(input,Edition::CURRENT).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 cfg = CfgExpr::parse(&tt);
@@ -23,7 +23,7 @@ fn check_dnf(input: &str, expect: Expect) {
 }
 
 fncheck_why_inactive(input:&str,opts:&CfgOptions,expect:Expect){
-let source_file = ast::SourceFile::parse(input).ok().unwrap();
+let source_file = ast::SourceFile::parse(input,Edition::CURRENT).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 cfg = CfgExpr::parse(&tt);
@@ -34,7 +34,7 @@ fn check_why_inactive(input: &str, opts: &CfgOptions, expect: Expect) {
 
 #[track_caller]
 fncheck_enable_hints(input:&str,opts:&CfgOptions,expected_hints:&[&str]){
-let source_file = ast::SourceFile::parse(input).ok().unwrap();
+let source_file = ast::SourceFile::parse(input,Edition::CURRENT).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 cfg = CfgExpr::parse(&tt);

crates/hir-def/src/attr/tests.rs

@@ -11,7 +11,7 @@ use syntax::{ast, AstNode, TextRange};
 usecrate::attr::{DocAtom,DocExpr};
 
 fnassert_parse_result(input:&str,expected:DocExpr){
-let source_file = ast::SourceFile::parse(input).ok().unwrap();
+let source_file = ast::SourceFile::parse(input, span::Edition::CURRENT).ok().unwrap();
 let tt = source_file.syntax().descendants().find_map(ast::TokenTree::cast).unwrap();
 let map = SpanMap::RealSpanMap(Arc::new(RealSpanMap::absolute(FileId::from_raw(0))));
 let tt = syntax_node_to_token_tree(

crates/hir-def/src/find_path.rs

@@ -610,7 +610,8 @@ mod tests {
 ){
 let(db, pos) = TestDB::with_position(ra_fixture);
 let module = db.module_at_position(pos);
-let parsed_path_file = syntax::SourceFile::parse(&format!("use {path};"));
+let parsed_path_file =
+ syntax::SourceFile::parse(&format!("use {path};"), span::Edition::CURRENT);
 let ast_path =
  parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();
 let mod_path = ModPath::from_src(&db, ast_path,&mut |range| {

crates/hir-expand/src/builtin_fn_macro.rs

@@ -219,7 +219,7 @@ fn assert_expand(
 span:Span,
 ) -> ExpandResult<tt::Subtree>{
 let call_site_span = span_with_call_site_ctxt(db, span, id);
-let args = parse_exprs_with_sep(tt,',', call_site_span);
+let args = parse_exprs_with_sep(tt,',', call_site_span,Edition::CURRENT);
 let dollar_crate = dollar_crate(span);
 let expanded = match&*args {
 [cond, panic_args @ ..] => {

crates/hir-expand/src/cfg_process.rs

@@ -327,7 +327,7 @@ mod tests {
 usecrate::cfg_process::parse_from_attr_meta;
 
 fncheck_dnf_from_syntax(input:&str,expect:Expect){
-let parse = SourceFile::parse(input);
+let parse = SourceFile::parse(input, span::Edition::CURRENT);
 let node = match parse.tree().syntax().descendants().find_map(Attr::cast){
 Some(it) => it,
 None => {

crates/hir-expand/src/db.rs

@@ -225,43 +225,45 @@ pub fn expand_speculative(
 
 // Do the actual expansion, we need to directly expand the proc macro due to the attribute args
 // Otherwise the expand query will fetch the non speculative attribute args and pass those instead.
-letmut speculative_expansion = match loc.def.kind{
-MacroDefKind::ProcMacro(expander, _, ast) => {
-let span = db.proc_macro_span(ast);
- tt.delimiter = tt::Delimiter::invisible_spanned(span);
- expander.expand(
- db,
- loc.def.krate,
- loc.krate,
-&tt,
- attr_arg.as_ref(),
-span_with_def_site_ctxt(db, span, actual_macro_call),
-span_with_call_site_ctxt(db, span, actual_macro_call),
-span_with_mixed_site_ctxt(db, span, actual_macro_call),
-)
-}
-MacroDefKind::BuiltInAttr(BuiltinAttrExpander::Derive, _) => {
-pseudo_derive_attr_expansion(&tt, attr_arg.as_ref()?, span)
-}
-MacroDefKind::Declarative(it) => {
- db.decl_macro_expander(loc.krate, it).expand_unhygienic(db, tt, loc.def.krate, span)
-}
-MacroDefKind::BuiltIn(it, _) => {
- it.expand(db, actual_macro_call,&tt, span).map_err(Into::into)
-}
-MacroDefKind::BuiltInDerive(it, ..) => {
- it.expand(db, actual_macro_call,&tt, span).map_err(Into::into)
-}
-MacroDefKind::BuiltInEager(it, _) => {
- it.expand(db, actual_macro_call,&tt, span).map_err(Into::into)
-}
-MacroDefKind::BuiltInAttr(it, _) => it.expand(db, actual_macro_call,&tt, span),
-};
+letmut speculative_expansion =
+match loc.def.kind{
+MacroDefKind::ProcMacro(expander, _, ast) => {
+let span = db.proc_macro_span(ast);
+ tt.delimiter = tt::Delimiter::invisible_spanned(span);
+ expander.expand(
+ db,
+ loc.def.krate,
+ loc.krate,
+&tt,
+ attr_arg.as_ref(),
+span_with_def_site_ctxt(db, span, actual_macro_call),
+span_with_call_site_ctxt(db, span, actual_macro_call),
+span_with_mixed_site_ctxt(db, span, actual_macro_call),
+)
+}
+MacroDefKind::BuiltInAttr(BuiltinAttrExpander::Derive, _) => {
+pseudo_derive_attr_expansion(&tt, attr_arg.as_ref()?, span)
+}
+MacroDefKind::Declarative(it) => db
+.decl_macro_expander(loc.krate, it)
+.expand_unhygienic(db, tt, loc.def.krate, span, loc.def.edition),
+MacroDefKind::BuiltIn(it, _) => {
+ it.expand(db, actual_macro_call,&tt, span).map_err(Into::into)
+}
+MacroDefKind::BuiltInDerive(it, ..) => {
+ it.expand(db, actual_macro_call,&tt, span).map_err(Into::into)
+}
+MacroDefKind::BuiltInEager(it, _) => {
+ it.expand(db, actual_macro_call,&tt, span).map_err(Into::into)
+}
+MacroDefKind::BuiltInAttr(it, _) => it.expand(db, actual_macro_call,&tt, span),
+};
 
 let expand_to = loc.expand_to();
 
  fixup::reverse_fixups(&mut speculative_expansion.value,&undo_info);
-let(node, rev_tmap) = token_tree_to_syntax_node(&speculative_expansion.value, expand_to);
+let(node, rev_tmap) =
+token_tree_to_syntax_node(&speculative_expansion.value, expand_to, loc.def.edition);
 
 let syntax_node = node.syntax_node();
 let token = rev_tmap
@@ -309,6 +311,7 @@ fn parse_macro_expansion(
 ) -> ExpandResult<(Parse<SyntaxNode>,Arc<ExpansionSpanMap>)>{
 let _p = tracing::span!(tracing::Level::INFO,"parse_macro_expansion").entered();
 let loc = db.lookup_intern_macro_call(macro_file.macro_call_id);
+let edition = loc.def.edition;
 let expand_to = loc.expand_to();
 let mbe::ValueResult{value: tt, err } = macro_expand(db, macro_file.macro_call_id, loc);
 
@@ -318,6 +321,7 @@ fn parse_macro_expansion(
 CowArc::Owned(it) => it,
 },
  expand_to,
+ edition,
 );
 
 ExpandResult{value:(parse,Arc::new(rev_token_map)), err }
@@ -668,6 +672,7 @@ fn expand_proc_macro(db: &dyn ExpandDatabase, id: MacroCallId) -> ExpandResult<A
 fntoken_tree_to_syntax_node(
 tt:&tt::Subtree,
 expand_to:ExpandTo,
+edition: parser::Edition,
 ) -> (Parse<SyntaxNode>,ExpansionSpanMap){
 let entry_point = match expand_to {
 ExpandTo::Statements => mbe::TopEntryPoint::MacroStmts,
@@ -676,7 +681,7 @@ fn token_tree_to_syntax_node(
 ExpandTo::Type => mbe::TopEntryPoint::Type,
 ExpandTo::Expr => mbe::TopEntryPoint::Expr,
 };
- mbe::token_tree_to_syntax_node(tt, entry_point,parser::Edition::CURRENT)
+ mbe::token_tree_to_syntax_node(tt, entry_point,edition)
 }
 
 fncheck_tt_count(tt:&tt::Subtree) -> Result<(),ExpandResult<()>>{

crates/hir-expand/src/declarative.rs

@@ -2,7 +2,7 @@
 use std::sync::OnceLock;
 
 use base_db::{CrateId,VersionReq};
-use span::{MacroCallId,Span,SyntaxContextId};
+use span::{Edition,MacroCallId,Span,SyntaxContextId};
 use syntax::{ast,AstNode};
 use triomphe::Arc;
 
@@ -56,6 +56,7 @@ impl DeclarativeMacroExpander {
  |s| s.ctx = apply_mark(db, s.ctx, call_id,self.transparency),
  new_meta_vars,
  span,
+ loc.def.edition,
 )
 .map_err(Into::into),
 }
@@ -67,6 +68,7 @@ impl DeclarativeMacroExpander {
 tt: tt::Subtree,
 krate:CrateId,
 call_site:Span,
+def_site_edition:Edition,
 ) -> ExpandResult<tt::Subtree>{
 let toolchain = db.toolchain(krate);
 let new_meta_vars = toolchain.as_ref().map_or(false, |version| {
@@ -85,7 +87,10 @@ impl DeclarativeMacroExpander {
  tt::Subtree::empty(tt::DelimSpan{open: call_site,close: call_site }),
 ExpandError::MacroDefinition,
 ),
-None => self.mac.expand(&tt, |_| (), new_meta_vars, call_site).map_err(Into::into),
+None => self
+.mac
+.expand(&tt, |_| (), new_meta_vars, call_site, def_site_edition)
+.map_err(Into::into),
 }
 }
 

crates/hir-expand/src/fixup.rs

@@ -396,7 +396,7 @@ mod tests {
 
 #[track_caller]
 fncheck(ra_fixture:&str,mutexpect:Expect){
-let parsed = syntax::SourceFile::parse(ra_fixture);
+let parsed = syntax::SourceFile::parse(ra_fixture, span::Edition::CURRENT);
 let span_map = SpanMap::RealSpanMap(Arc::new(RealSpanMap::absolute(FileId::from_raw(0))));
 let fixups = super::fixup_syntax(
  span_map.as_ref(),

crates/ide-completion/src/context.rs

@@ -17,7 +17,7 @@ use ide_db::{
 };
 use syntax::{
  ast::{self,AttrKind,NameOrNameRef},
-AstNode,SmolStr,
+AstNode,Edition,SmolStr,
 SyntaxKind::{self,*},
 SyntaxToken,TextRange,TextSize,T,
 };
@@ -667,7 +667,8 @@ impl<'a> CompletionContext<'a> {
 let file_with_fake_ident = {
 let parse = db.parse(file_id);
 let edit = Indel::insert(offset,COMPLETION_MARKER.to_owned());
- parse.reparse(&edit).tree()
+// FIXME: Edition
+ parse.reparse(&edit,Edition::CURRENT).tree()
 };
 
 // always pick the token to the immediate left of the cursor, as that is what we are actually