refactor: apply rustc mod parsing changes

[rust.git] / src / utils.rs

diff --git a/src/utils.rs b/src/utils.rs
index 494d4d0e33fc0e13c8e9fd240a5018f2b407bc9d..d3c349fb701e18050e574a9d35e69debf5845799 100644 (file)
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,13 +1,12 @@
 use std::borrow::Cow;
 
-use rustc_ast_pretty::pprust;
-use rustc_span::{sym, BytePos, ExpnId, Span, Symbol, SyntaxContext};
-use rustc_target::spec::abi;
-use syntax::ast::{
+use rustc_ast::ast::{
     self, Attribute, CrateSugar, MetaItem, MetaItemKind, NestedMetaItem, NodeId, Path, Visibility,
     VisibilityKind,
 };
-use syntax::ptr;
+use rustc_ast::ptr;
+use rustc_ast_pretty::pprust;
+use rustc_span::{sym, symbol, BytePos, ExpnId, Span, Symbol, SyntaxContext};
 use unicode_width::UnicodeWidthStr;
 
 use crate::comment::{filter_normal_code, CharClasses, FullCodeCharKind, LineClasses};
@@ -25,7 +24,7 @@ pub(crate) fn skip_annotation() -> Symbol {
     Symbol::intern("rustfmt::skip")
 }
 
-pub(crate) fn rewrite_ident<'a>(context: &'a RewriteContext<'_>, ident: ast::Ident) -> &'a str {
+pub(crate) fn rewrite_ident<'a>(context: &'a RewriteContext<'_>, ident: symbol::Ident) -> &'a str {
     context.snippet(ident.span)
 }
 
@@ -39,11 +38,11 @@ pub(crate) fn extra_offset(text: &str, shape: Shape) -> usize {
 }
 
 pub(crate) fn is_same_visibility(a: &Visibility, b: &Visibility) -> bool {
-    match (&a.node, &b.node) {
+    match (&a.kind, &b.kind) {
         (
             VisibilityKind::Restricted { path: p, .. },
             VisibilityKind::Restricted { path: q, .. },
-        ) => pprust::path_to_string(p) == pprust::path_to_string(q),
+        ) => pprust::path_to_string(&p) == pprust::path_to_string(&q),
         (VisibilityKind::Public, VisibilityKind::Public)
         | (VisibilityKind::Inherited, VisibilityKind::Inherited)
         | (
@@ -63,7 +62,7 @@ pub(crate) fn format_visibility(
     context: &RewriteContext<'_>,
     vis: &Visibility,
 ) -> Cow<'static, str> {
-    match vis.node {
+    match vis.kind {
         VisibilityKind::Public => Cow::from("pub "),
         VisibilityKind::Inherited => Cow::from(""),
         VisibilityKind::Crate(CrateSugar::PubCrate) => Cow::from("pub(crate) "),
@@ -101,6 +100,14 @@ pub(crate) fn format_constness(constness: ast::Const) -> &'static str {
     }
 }
 
+#[inline]
+pub(crate) fn format_constness_right(constness: ast::Const) -> &'static str {
+    match constness {
+        ast::Const::Yes(..) => " const",
+        ast::Const::No => "",
+    }
+}
+
 #[inline]
 pub(crate) fn format_defaultness(defaultness: ast::Defaultness) -> &'static str {
     match defaultness {
@@ -140,24 +147,22 @@ pub(crate) fn format_extern(
     is_mod: bool,
 ) -> Cow<'static, str> {
     let abi = match ext {
-        ast::Extern::None => abi::Abi::Rust,
-        ast::Extern::Implicit => abi::Abi::C,
-        ast::Extern::Explicit(abi) => {
-            abi::lookup(&abi.symbol_unescaped.as_str()).unwrap_or(abi::Abi::Rust)
-        }
+        ast::Extern::None => "Rust".to_owned(),
+        ast::Extern::Implicit => "C".to_owned(),
+        ast::Extern::Explicit(abi) => abi.symbol_unescaped.to_string(),
     };
 
-    if abi == abi::Abi::Rust && !is_mod {
+    if abi == "Rust" && !is_mod {
         Cow::from("")
-    } else if abi == abi::Abi::C && !explicit_abi {
+    } else if abi == "C" && !explicit_abi {
         Cow::from("extern ")
     } else {
-        Cow::from(format!("extern {} ", abi))
+        Cow::from(format!(r#"extern "{}" "#, abi))
     }
 }
 
 #[inline]
-// Transform `Vec<syntax::ptr::P<T>>` into `Vec<&T>`
+// Transform `Vec<rustc_ast::ptr::P<T>>` into `Vec<&T>`
 pub(crate) fn ptr_vec_to_ref_vec<T>(vec: &[ptr::P<T>]) -> Vec<&T> {
     vec.iter().map(|x| &**x).collect::<Vec<_>>()
 }
@@ -259,7 +264,7 @@ fn is_skip(meta_item: &MetaItem) -> bool {
                 || path_str == &*depr_skip_annotation().as_str()
         }
         MetaItemKind::List(ref l) => {
-            meta_item.check_name(sym::cfg_attr) && l.len() == 2 && is_skip_nested(&l[1])
+            meta_item.has_name(sym::cfg_attr) && l.len() == 2 && is_skip_nested(&l[1])
         }
         _ => false,
     }
@@ -282,6 +287,13 @@ pub(crate) fn contains_skip(attrs: &[Attribute]) -> bool {
 
 #[inline]
 pub(crate) fn semicolon_for_expr(context: &RewriteContext<'_>, expr: &ast::Expr) -> bool {
+    // Never try to insert semicolons on expressions when we're inside
+    // a macro definition - this can prevent the macro from compiling
+    // when used in expression position
+    if context.is_macro_def {
+        return false;
+    }
+
     match expr.kind {
         ast::ExprKind::Ret(..) | ast::ExprKind::Continue(..) | ast::ExprKind::Break(..) => {
             context.config.trailing_semicolon()
@@ -348,6 +360,10 @@ pub(crate) fn mk_sp(lo: BytePos, hi: BytePos) -> Span {
     Span::new(lo, hi, SyntaxContext::root())
 }
 
+pub(crate) fn mk_sp_lo_plus_one(lo: BytePos) -> Span {
+    Span::new(lo, lo + BytePos(1), SyntaxContext::root())
+}
+
 // Returns `true` if the given span does not intersect with file lines.
 macro_rules! out_of_file_lines_range {
     ($self:ident, $span:expr) => {
@@ -464,6 +480,7 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::While(..)
         | ast::ExprKind::If(..)
         | ast::ExprKind::Block(..)
+        | ast::ExprKind::ConstBlock(..)
         | ast::ExprKind::Async(..)
         | ast::ExprKind::Loop(..)
         | ast::ExprKind::ForLoop(..)
@@ -491,6 +508,7 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::Err
         | ast::ExprKind::Field(..)
         | ast::ExprKind::InlineAsm(..)
+        | ast::ExprKind::LlvmInlineAsm(..)
         | ast::ExprKind::Let(..)
         | ast::ExprKind::Path(..)
         | ast::ExprKind::Range(..)
@@ -498,7 +516,8 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::Ret(..)
         | ast::ExprKind::Tup(..)
         | ast::ExprKind::Type(..)
-        | ast::ExprKind::Yield(None) => false,
+        | ast::ExprKind::Yield(None)
+        | ast::ExprKind::Underscore => false,
     }
 }