Merge pull request #1638 from est31/master

Update syntex to 0.59

Author: nrc

Cargo.lock

@@ -28,8 +28,8 @@ regex = "0.2"
 term = "0.4"
 strings = "0.1"
 diff = "0.1"
-syntex_syntax = "0.58"
-syntex_errors = "0.58"
+syntex_syntax = "0.59"
+syntex_errors = "0.59"
 log = "0.3"
 env_logger = "0.4"
 getopts = "0.2"

Cargo.toml

@@ -78,15 +78,15 @@
 
 use Shape;
 use rewrite::{Rewrite, RewriteContext};
-use utils::{wrap_str, first_line_width, last_line_width};
+use utils::{wrap_str, first_line_width, last_line_width, mk_sp};
 use expr::rewrite_call;
 use config::IndentStyle;
 use macros::convert_try_mac;
 
 use std::cmp::min;
 use std::iter;
 use syntax::{ast, ptr};
-use syntax::codemap::{mk_sp, Span};
+use syntax::codemap::Span;
 
 pub fn rewrite_chain(expr: &ast::Expr, context: &RewriteContext, shape: Shape) -> Option<String> {
     debug!("rewrite_chain {:?}", shape);

src/chains.rs

@@ -22,7 +22,7 @@ use lists::{write_list, itemize_list, ListFormatting, SeparatorTactic, ListTacti
 use string::{StringFormat, rewrite_string};
 use utils::{extra_offset, last_line_width, wrap_str, binary_search, first_line_width,
             semicolon_for_stmt, trimmed_last_line_width, left_most_sub_expr, stmt_expr,
-            colon_spaces, contains_skip};
+            colon_spaces, contains_skip, mk_sp};
 use visitor::FmtVisitor;
 use config::{Config, IndentStyle, MultilineStyle, ControlBraceStyle, Style};
 use comment::{FindUncommented, rewrite_comment, contains_comment, recover_comment_removed};
@@ -32,7 +32,7 @@ use chains::rewrite_chain;
 use macros::{rewrite_macro, MacroPosition};
 
 use syntax::{ast, ptr};
-use syntax::codemap::{CodeMap, Span, BytePos, mk_sp};
+use syntax::codemap::{CodeMap, Span, BytePos};
 use syntax::parse::classify;
 
 impl Rewrite for ast::Expr {
@@ -253,6 +253,16 @@ fn format_expr(expr: &ast::Expr,
                      context.config.max_width(),
                      shape)
         }
+        ast::ExprKind::Catch(ref block) => {
+            if let rewrite @ Some(_) = try_one_line_block(context, shape, "do catch ", block) {
+                return rewrite;
+            }
+            // 9 = `do catch `
+            let budget = shape.width.checked_sub(9).unwrap_or(0);
+            Some(format!("{}{}",
+                         "do catch ",
+                         try_opt!(block.rewrite(&context, Shape::legacy(budget, shape.indent)))))
+        }
     };
     match (attr_rw, expr_rw) {
         (Some(attr_str), Some(expr_str)) => {
@@ -266,6 +276,22 @@ fn format_expr(expr: &ast::Expr,
     }
 }
 
+fn try_one_line_block(context: &RewriteContext,
+                      shape: Shape,
+                      prefix: &str,
+                      block: &ast::Block)
+                      -> Option<String> {
+    if is_simple_block(block, context.codemap) {
+        let expr_shape = Shape::legacy(shape.width - prefix.len(), shape.indent);
+        let expr_str = try_opt!(block.stmts[0].rewrite(context, expr_shape));
+        let result = format!("{}{{ {} }}", prefix, expr_str);
+        if result.len() <= shape.width && !result.contains('\n') {
+            return Some(result);
+        }
+    }
+    None
+}
+
 pub fn rewrite_pair<LHS, RHS>(lhs: &LHS,
                               rhs: &RHS,
                               prefix: &str,
@@ -620,9 +646,7 @@ fn rewrite_closure(capture: ast::CaptureBy,
         // means we must re-format.
         let block_shape = shape.block().with_max_width(context.config);
         let block_str = try_opt!(block.rewrite(&context, block_shape));
-        Some(format!("{} {}",
-                     prefix,
-                     try_opt!(block_str.rewrite(context, block_shape))))
+        Some(format!("{} {}", prefix, block_str))
     }
 }
 
@@ -687,24 +711,13 @@ impl Rewrite for ast::Block {
                 } else {
                     "unsafe ".to_owned()
                 };
-
-                if is_simple_block(self, context.codemap) && prefix.len() < shape.width {
-                    let expr_str =
-                        self.stmts[0].rewrite(context,
-                                              Shape::legacy(shape.width - prefix.len(),
-                                                            shape.indent));
-                    let expr_str = try_opt!(expr_str);
-                    let result = format!("{}{{ {} }}", prefix, expr_str);
-                    if result.len() <= shape.width && !result.contains('\n') {
-                        return Some(result);
-                    }
+                if let result @ Some(_) = try_one_line_block(context, shape, &prefix, self) {
+                    return result;
                 }
-
                 prefix
             }
             ast::BlockCheckMode::Default => {
                 visitor.last_pos = self.span.lo;
-
                 String::new()
             }
         };

src/expr.rs

@@ -10,7 +10,7 @@
 
 use Shape;
 use utils;
-use syntax::codemap::{self, BytePos, Span};
+use syntax::codemap::{BytePos, Span};
 use codemap::SpanUtils;
 use lists::{write_list, itemize_list, ListItem, ListFormatting, SeparatorTactic, definitive_tactic};
 use types::{rewrite_path, PathContext};
@@ -202,7 +202,7 @@ impl<'a> FmtVisitor<'a> {
         // Order the imports by view-path & other import path properties
         ordered_use_items.sort_by(|a, b| compare_use_items(a.0, b.0).unwrap());
         // First, output the span before the first import
-        let prev_span_str = self.snippet(codemap::mk_sp(self.last_pos, pos_before_first_use_item));
+        let prev_span_str = self.snippet(utils::mk_sp(self.last_pos, pos_before_first_use_item));
         // Look for purely trailing space at the start of the prefix snippet before a linefeed, or
         // a prefix that's entirely horizontal whitespace.
         let prefix_span_start = match prev_span_str.find('\n') {
@@ -241,7 +241,7 @@ impl<'a> FmtVisitor<'a> {
                          Shape::legacy(self.config.max_width() - offset.width() - 1, offset)) {
             Some(ref s) if s.is_empty() => {
                 // Format up to last newline
-                let prev_span = codemap::mk_sp(self.last_pos, source!(self, span).lo);
+                let prev_span = utils::mk_sp(self.last_pos, source!(self, span).lo);
                 let span_end = match self.snippet(prev_span).rfind('\n') {
                     Some(offset) => self.last_pos + BytePos(offset as u32),
                     None => source!(self, span).lo,

src/imports.rs

@@ -14,7 +14,7 @@ use {Indent, Shape};
 use codemap::SpanUtils;
 use utils::{format_mutability, format_visibility, contains_skip, end_typaram, wrap_str,
             last_line_width, format_unsafety, trim_newlines, stmt_expr, semicolon_for_expr,
-            trimmed_last_line_width, colon_spaces};
+            trimmed_last_line_width, colon_spaces, mk_sp};
 use lists::{write_list, itemize_list, ListItem, ListFormatting, SeparatorTactic, list_helper,
             DefinitiveListTactic, ListTactic, definitive_tactic, format_item_list};
 use expr::{is_empty_block, is_simple_block_stmt, rewrite_assign_rhs};
@@ -23,8 +23,8 @@ use visitor::FmtVisitor;
 use rewrite::{Rewrite, RewriteContext};
 use config::{Config, IndentStyle, Density, ReturnIndent, BraceStyle, Style, TypeDensity};
 
-use syntax::{ast, abi, codemap, ptr, symbol};
-use syntax::codemap::{Span, BytePos, mk_sp};
+use syntax::{ast, abi, ptr, symbol};
+use syntax::codemap::{Span, BytePos};
 use syntax::ast::ImplItem;
 
 fn type_annotation_separator(config: &Config) -> &str {
@@ -246,7 +246,7 @@ impl<'a> FmtVisitor<'a> {
         let mut newline_brace = newline_for_brace(self.config, &generics.where_clause);
         let context = self.get_context();
 
-        let block_snippet = self.snippet(codemap::mk_sp(block.span.lo, block.span.hi));
+        let block_snippet = self.snippet(mk_sp(block.span.lo, block.span.hi));
         let has_body = !block_snippet[1..block_snippet.len() - 1].trim().is_empty() ||
                        !context.config.fn_empty_single_line();
 
@@ -527,7 +527,7 @@ pub fn format_impl(context: &RewriteContext,
                    offset: Indent,
                    where_span_end: Option<BytePos>)
                    -> Option<String> {
-    if let ast::ItemKind::Impl(_, _, ref generics, ref trait_ref, _, ref items) = item.node {
+    if let ast::ItemKind::Impl(_, _, _, ref generics, ref trait_ref, _, ref items) = item.node {
         let mut result = String::new();
         // First try to format the ref and type without a split at the 'for'.
         let mut ref_and_type = try_opt!(format_impl_ref_and_type(context, item, offset, false));
@@ -647,8 +647,13 @@ fn format_impl_ref_and_type(context: &RewriteContext,
                             offset: Indent,
                             split_at_for: bool)
                             -> Option<String> {
-    if let ast::ItemKind::Impl(unsafety, polarity, ref generics, ref trait_ref, ref self_ty, _) =
-        item.node {
+    if let ast::ItemKind::Impl(unsafety,
+                               polarity,
+                               _,
+                               ref generics,
+                               ref trait_ref,
+                               ref self_ty,
+                               _) = item.node {
         let mut result = String::new();
 
         result.push_str(&format_visibility(&item.vis));

src/items.rs

@@ -33,7 +33,7 @@ extern crate term;
 use errors::{Handler, DiagnosticBuilder};
 use errors::emitter::{ColorConfig, EmitterWriter};
 use syntax::ast;
-use syntax::codemap::{mk_sp, CodeMap, Span};
+use syntax::codemap::{CodeMap, Span, FilePathMapping};
 use syntax::parse::{self, ParseSess};
 
 use strings::string_buffer::StringBuffer;
@@ -107,7 +107,7 @@ impl Spanned for ast::Ty {
 impl Spanned for ast::Arg {
     fn span(&self) -> Span {
         if items::is_named_arg(self) {
-            mk_sp(self.pat.span.lo, self.ty.span.hi)
+            utils::mk_sp(self.pat.span.lo, self.ty.span.hi)
         } else {
             self.ty.span
         }
@@ -578,7 +578,7 @@ pub fn format_input<T: Write>(input: Input,
     if config.disable_all_formatting() {
         return Ok((summary, FileMap::new(), FormatReport::new()));
     }
-    let codemap = Rc::new(CodeMap::new());
+    let codemap = Rc::new(CodeMap::new(FilePathMapping::empty()));
 
     let tty_handler =
         Handler::with_tty_emitter(ColorConfig::Auto, true, false, Some(codemap.clone()));

src/lib.rs

@@ -11,12 +11,13 @@
 use std::cmp;
 use std::iter::Peekable;
 
-use syntax::codemap::{self, CodeMap, BytePos};
+use syntax::codemap::{CodeMap, BytePos};
 
 use {Indent, Shape};
 use comment::{FindUncommented, rewrite_comment, find_comment_end};
 use config::{Config, IndentStyle};
 use rewrite::RewriteContext;
+use utils::mk_sp;
 
 #[derive(Eq, PartialEq, Debug, Copy, Clone)]
 /// Formatting tactic for lists. This will be cast down to a
@@ -344,7 +345,7 @@ impl<'a, T, I, F1, F2, F3> Iterator for ListItems<'a, I, F1, F2, F3>
             let mut new_lines = false;
             // Pre-comment
             let pre_snippet = self.codemap
-                .span_to_snippet(codemap::mk_sp(self.prev_span_end, (self.get_lo)(&item)))
+                .span_to_snippet(mk_sp(self.prev_span_end, (self.get_lo)(&item)))
                 .unwrap();
             let trimmed_pre_snippet = pre_snippet.trim();
             let has_pre_comment = trimmed_pre_snippet.contains("//") ||
@@ -361,7 +362,7 @@ impl<'a, T, I, F1, F2, F3> Iterator for ListItems<'a, I, F1, F2, F3>
                 None => self.next_span_start,
             };
             let post_snippet = self.codemap
-                .span_to_snippet(codemap::mk_sp((self.get_hi)(&item), next_start))
+                .span_to_snippet(mk_sp((self.get_hi)(&item), next_start))
                 .unwrap();
 
             let comment_end = match self.inner.peek() {

src/lists.rs

@@ -20,9 +20,10 @@
 // and those with brackets will be formatted as array literals.
 
 use syntax::ast;
-use syntax::codemap::{mk_sp, BytePos};
+use syntax::codemap::BytePos;
 use syntax::parse::token::Token;
-use syntax::parse::tts_to_parser;
+use syntax::parse::new_parser_from_tts;
+use syntax::tokenstream::TokenStream;
 use syntax::symbol;
 use syntax::util::ThinVec;
 
@@ -31,6 +32,7 @@ use codemap::SpanUtils;
 use rewrite::{Rewrite, RewriteContext};
 use expr::{rewrite_call, rewrite_array, rewrite_pair};
 use comment::{FindUncommented, contains_comment};
+use utils::mk_sp;
 
 const FORCED_BRACKET_MACROS: &'static [&'static str] = &["vec!"];
 
@@ -92,7 +94,8 @@ pub fn rewrite_macro(mac: &ast::Mac,
         original_style
     };
 
-    if mac.node.tts.is_empty() && !contains_comment(&context.snippet(mac.span)) {
+    let ts: TokenStream = mac.node.tts.clone().into();
+    if ts.is_empty() && !contains_comment(&context.snippet(mac.span)) {
         return match style {
             MacroStyle::Parens if position == MacroPosition::Item => {
                 Some(format!("{}();", macro_name))
@@ -103,7 +106,7 @@ pub fn rewrite_macro(mac: &ast::Mac,
         };
     }
 
-    let mut parser = tts_to_parser(context.parse_session, mac.node.tts.clone());
+    let mut parser = new_parser_from_tts(context.parse_session, ts.trees().collect());
     let mut expr_vec = Vec::new();
     let mut vec_with_semi = false;
 
@@ -222,7 +225,8 @@ pub fn rewrite_macro(mac: &ast::Mac,
 /// failed).
 pub fn convert_try_mac(mac: &ast::Mac, context: &RewriteContext) -> Option<ast::Expr> {
     if &format!("{}", mac.node.path)[..] == "try" {
-        let mut parser = tts_to_parser(context.parse_session, mac.node.tts.clone());
+        let ts: TokenStream = mac.node.tts.clone().into();
+        let mut parser = new_parser_from_tts(context.parse_session, ts.trees().collect());
 
         Some(ast::Expr {
                  id: ast::NodeId::new(0), // dummy value

src/macros.rs

@@ -10,9 +10,10 @@
 
 use config::WriteMode;
 use visitor::FmtVisitor;
-use syntax::codemap::{self, BytePos, Span, Pos};
+use syntax::codemap::{BytePos, Span, Pos};
 use comment::{CodeCharKind, CommentCodeSlices, rewrite_comment};
 use Shape;
+use utils::mk_sp;
 
 impl<'a> FmtVisitor<'a> {
     fn output_at_start(&self) -> bool {
@@ -65,7 +66,7 @@ impl<'a> FmtVisitor<'a> {
                 self.codemap.lookup_char_pos(end));
 
         self.last_pos = end;
-        let span = codemap::mk_sp(start, end);
+        let span = mk_sp(start, end);
 
         self.write_snippet(span, &process_last_snippet);
     }

src/missed_spans.rs

@@ -12,7 +12,7 @@ use Shape;
 use codemap::SpanUtils;
 use config::{IndentStyle, MultilineStyle};
 use rewrite::{Rewrite, RewriteContext};
-use utils::{wrap_str, format_mutability};
+use utils::{wrap_str, format_mutability, mk_sp};
 use lists::{DefinitiveListTactic, SeparatorTactic, format_item_list, itemize_list, ListItem,
             struct_lit_shape, struct_lit_tactic, shape_for_tactic, struct_lit_formatting,
             write_list};
@@ -261,14 +261,14 @@ fn rewrite_tuple_pat(pats: &[ptr::P<ast::Pat>],
         } else {
             pats[pos + 1].span().lo
         };
-        let dot_span = codemap::mk_sp(prev, next);
+        let dot_span = mk_sp(prev, next);
         let snippet = context.snippet(dot_span);
         let lo = dot_span.lo + BytePos(snippet.find_uncommented("..").unwrap() as u32);
         let span = Span {
             lo: lo,
             // 2 == "..".len()
             hi: lo + BytePos(2),
-            expn_id: codemap::NO_EXPANSION,
+            ctxt: codemap::NO_EXPANSION,
         };
         let dotdot = TuplePatField::Dotdot(span);
         pat_vec.insert(pos, dotdot);

src/patterns.rs

@@ -21,7 +21,7 @@ use {Shape, Spanned};
 use codemap::SpanUtils;
 use lists::{format_item_list, itemize_list, format_fn_args};
 use rewrite::{Rewrite, RewriteContext};
-use utils::{extra_offset, format_mutability, colon_spaces, wrap_str};
+use utils::{extra_offset, format_mutability, colon_spaces, wrap_str, mk_sp};
 use expr::{rewrite_unary_prefix, rewrite_pair, rewrite_tuple_type};
 use config::TypeDensity;
 
@@ -206,9 +206,7 @@ fn rewrite_segment(path_context: PathContext,
                     .collect::<Vec<_>>();
 
                 let next_span_lo = param_list.last().unwrap().get_span().hi + BytePos(1);
-                let list_lo = context
-                    .codemap
-                    .span_after(codemap::mk_sp(*span_lo, span_hi), "<");
+                let list_lo = context.codemap.span_after(mk_sp(*span_lo, span_hi), "<");
                 let separator = if path_context == PathContext::Expr {
                     "::"
                 } else {
@@ -686,6 +684,7 @@ impl Rewrite for ast::Ty {
                 it.rewrite(context, shape)
                     .map(|it_str| format!("impl {}", it_str))
             }
+            ast::TyKind::Err |
             ast::TyKind::Typeof(..) => unreachable!(),
         }
     }