// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use std::borrow::Cow;
use std::cmp::Ordering;
-use syntax::ast::{self, Visibility, Attribute, MetaItem, MetaItemKind};
-use syntax::codemap::{CodeMap, Span, BytePos};
+use itertools::Itertools;
+
+use syntax::ast::{self, Visibility, Attribute, MetaItem, MetaItemKind, NestedMetaItem,
+ NestedMetaItemKind, Path};
+use syntax::codemap::BytePos;
use syntax::abi;
-use Indent;
-use comment::FindUncommented;
+use Shape;
use rewrite::{Rewrite, RewriteContext};
use SKIP_ANNOTATION;
-pub trait CodeMapSpanUtils {
- fn span_after(&self, original: Span, needle: &str) -> BytePos;
- fn span_after_last(&self, original: Span, needle: &str) -> BytePos;
- fn span_before(&self, original: Span, needle: &str) -> BytePos;
-}
-
-impl CodeMapSpanUtils for CodeMap {
- #[inline]
- fn span_after(&self, original: Span, needle: &str) -> BytePos {
- let snippet = self.span_to_snippet(original).unwrap();
- let offset = snippet.find_uncommented(needle).unwrap() + needle.len();
-
- original.lo + BytePos(offset as u32)
- }
-
- #[inline]
- fn span_after_last(&self, original: Span, needle: &str) -> BytePos {
- let snippet = self.span_to_snippet(original).unwrap();
- let mut offset = 0;
-
- while let Some(additional_offset) = snippet[offset..].find_uncommented(needle) {
- offset += additional_offset + needle.len();
- }
-
- original.lo + BytePos(offset as u32)
- }
-
- #[inline]
- fn span_before(&self, original: Span, needle: &str) -> BytePos {
- let snippet = self.span_to_snippet(original).unwrap();
- let offset = snippet.find_uncommented(needle).unwrap();
-
- original.lo + BytePos(offset as u32)
- }
-}
-
// Computes the length of a string's last line, minus offset.
-#[inline]
-pub fn extra_offset(text: &str, offset: Indent) -> usize {
+pub fn extra_offset(text: &str, shape: Shape) -> usize {
match text.rfind('\n') {
// 1 for newline character
- Some(idx) => text.len() - idx - 1 - offset.width(),
+ Some(idx) => text.len().checked_sub(idx + 1 + shape.used_width()).unwrap_or(0),
None => text.len(),
}
}
-#[inline]
-pub fn format_visibility(vis: Visibility) -> &'static str {
- match vis {
- Visibility::Public => "pub ",
- Visibility::Inherited => "",
+// Uses Cow to avoid allocating in the common cases.
+pub fn format_visibility(vis: &Visibility) -> Cow<'static, str> {
+ match *vis {
+ Visibility::Public => Cow::from("pub "),
+ Visibility::Inherited => Cow::from(""),
+ Visibility::Crate(_) => Cow::from("pub(crate) "),
+ Visibility::Restricted { ref path, .. } => {
+ let Path { ref segments, .. } = **path;
+ let mut segments_iter = segments.iter().map(|seg| seg.identifier.name.as_str());
+ if path.is_global() {
+ segments_iter.next().expect("Non-global path in pub(restricted)?");
+ }
+
+ Cow::from(format!("pub({}) ", segments_iter.join("::")))
+ }
}
}
#[inline]
fn is_skip(meta_item: &MetaItem) -> bool {
match meta_item.node {
- MetaItemKind::Word(ref s) => *s == SKIP_ANNOTATION,
- MetaItemKind::List(ref s, ref l) => *s == "cfg_attr" && l.len() == 2 && is_skip(&l[1]),
+ MetaItemKind::Word => meta_item.name == SKIP_ANNOTATION,
+ MetaItemKind::List(ref l) => {
+ meta_item.name == "cfg_attr" && l.len() == 2 && is_skip_nested(&l[1])
+ }
_ => false,
}
}
+#[inline]
+fn is_skip_nested(meta_item: &NestedMetaItem) -> bool {
+ match meta_item.node {
+ NestedMetaItemKind::MetaItem(ref mi) => is_skip(mi),
+ NestedMetaItemKind::Literal(_) => false,
+ }
+}
+
#[inline]
pub fn contains_skip(attrs: &[Attribute]) -> bool {
- attrs.iter().any(|a| is_skip(&a.node.value))
+ attrs.iter().any(|a| is_skip(&a.value))
}
// Find the end of a TyParam
pub fn end_typaram(typaram: &ast::TyParam) -> BytePos {
typaram.bounds
.last()
- .map_or(typaram.span, |bound| {
- match *bound {
- ast::RegionTyParamBound(ref lt) => lt.span,
- ast::TraitTyParamBound(ref prt, _) => prt.span,
- }
+ .map_or(typaram.span, |bound| match *bound {
+ ast::RegionTyParamBound(ref lt) => lt.span,
+ ast::TraitTyParamBound(ref prt, _) => prt.span,
})
.hi
}
pub fn semicolon_for_expr(expr: &ast::Expr) -> bool {
match expr.node {
ast::ExprKind::Ret(..) |
- ast::ExprKind::Again(..) |
+ ast::ExprKind::Continue(..) |
ast::ExprKind::Break(..) => true,
_ => false,
}
#[inline]
pub fn semicolon_for_stmt(stmt: &ast::Stmt) -> bool {
match stmt.node {
- ast::StmtKind::Semi(ref expr, _) => {
+ ast::StmtKind::Semi(ref expr) => {
match expr.node {
ast::ExprKind::While(..) |
ast::ExprKind::WhileLet(..) |
}
}
+#[inline]
+pub fn stmt_expr(stmt: &ast::Stmt) -> Option<&ast::Expr> {
+ match stmt.node {
+ ast::StmtKind::Expr(ref expr) => Some(expr),
+ _ => None,
+ }
+}
+
#[inline]
pub fn trim_newlines(input: &str) -> &str {
match input.find(|c| c != '\n' && c != '\r') {
)
}
+// For format_missing and last_pos, need to use the source callsite (if applicable).
+// Required as generated code spans aren't guaranteed to follow on from the last span.
+macro_rules! source {
+ ($this:ident, $sp: expr) => {
+ $this.codemap.source_callsite($sp)
+ }
+}
// Wraps string-like values in an Option. Returns Some when the string adheres
// to the Rewrite constraints defined for the Rewrite trait and else otherwise.
-pub fn wrap_str<S: AsRef<str>>(s: S, max_width: usize, width: usize, offset: Indent) -> Option<S> {
+pub fn wrap_str<S: AsRef<str>>(s: S, max_width: usize, shape: Shape) -> Option<S> {
{
let snippet = s.as_ref();
- if !snippet.contains('\n') && snippet.len() > width {
+ if !snippet.contains('\n') && snippet.len() > shape.width {
return None;
} else {
let mut lines = snippet.lines();
- // The caller of this function has already placed `offset`
+ // The caller of this function has already placed `shape.offset`
// characters on the first line.
- let first_line_max_len = try_opt!(max_width.checked_sub(offset.width()));
+ let first_line_max_len = try_opt!(max_width.checked_sub(shape.indent.width()));
if lines.next().unwrap().len() > first_line_max_len {
return None;
}
// The other lines must fit within the maximum width.
- if lines.find(|line| line.len() > max_width).is_some() {
+ if lines.any(|line| line.len() > max_width) {
return None;
}
// indentation.
// A special check for the last line, since the caller may
// place trailing characters on this line.
- if snippet.lines().rev().next().unwrap().len() > offset.width() + width {
+ if snippet.lines()
+ .rev()
+ .next()
+ .unwrap()
+ .len() > shape.indent.width() + shape.width {
return None;
}
}
}
impl Rewrite for String {
- fn rewrite(&self, context: &RewriteContext, width: usize, offset: Indent) -> Option<String> {
- wrap_str(self, context.config.max_width, width, offset).map(ToOwned::to_owned)
+ fn rewrite(&self, context: &RewriteContext, shape: Shape) -> Option<String> {
+ wrap_str(self, context.config.max_width, shape).map(ToOwned::to_owned)
}
}
#[test]
fn bin_search_test() {
- let closure = |i| {
- match i {
- 4 => Ok(()),
- j if j > 4 => Err(Ordering::Less),
- j if j < 4 => Err(Ordering::Greater),
- _ => unreachable!(),
- }
+ let closure = |i| match i {
+ 4 => Ok(()),
+ j if j > 4 => Err(Ordering::Less),
+ j if j < 4 => Err(Ordering::Greater),
+ _ => unreachable!(),
};
assert_eq!(Some(()), binary_search(1, 10, &closure));
ast::ExprKind::Field(ref e, _) |
ast::ExprKind::TupField(ref e, _) |
ast::ExprKind::Index(ref e, _) |
- ast::ExprKind::Range(Some(ref e), _, _) => left_most_sub_expr(e),
- // FIXME needs Try in Syntex
- // ast::ExprKind::Try(ref f) => left_most_sub_expr(e),
+ ast::ExprKind::Range(Some(ref e), _, _) |
+ ast::ExprKind::Try(ref e) => left_most_sub_expr(e),
_ => e,
}
}
projects / rust.git / blobdiff