// 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;
// 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 span_after(original: Span, needle: &str, codemap: &CodeMap) -> BytePos {
- let snippet = codemap.span_to_snippet(original).unwrap();
- let offset = snippet.find_uncommented(needle).unwrap() + needle.len();
-
- original.lo + BytePos(offset as u32)
-}
-
-#[inline]
-pub fn span_before(original: Span, needle: &str, codemap: &CodeMap) -> BytePos {
- let snippet = codemap.span_to_snippet(original).unwrap();
- let offset = snippet.find_uncommented(needle).unwrap();
-
- original.lo + BytePos(offset as u32)
-}
-
-#[inline]
-pub fn span_after_last(original: Span, needle: &str, codemap: &CodeMap) -> BytePos {
- let snippet = codemap.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)
-}
+// 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)?");
+ }
-#[inline]
-pub fn format_visibility(vis: Visibility) -> &'static str {
- match vis {
- Visibility::Public => "pub ",
- Visibility::Inherited => "",
+ Cow::from(format!("pub({}) ", segments_iter.join("::")))
+ }
}
}
}
#[inline]
-// FIXME(#451): include "C"?
-pub fn format_abi(abi: abi::Abi) -> String {
- format!("extern {} ", abi)
+pub fn format_abi(abi: abi::Abi, explicit_abi: bool) -> String {
+ if abi == abi::Abi::C && !explicit_abi {
+ "extern ".into()
+ } else {
+ format!("extern {} ", abi)
+ }
}
// The width of the first line in s.
None => s.len(),
}
}
+#[inline]
+pub fn trimmed_last_line_width(s: &str) -> usize {
+ match s.rfind('\n') {
+ Some(n) => s[(n + 1)..].trim().len(),
+ None => s.trim().len(),
+ }
+}
#[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
#[inline]
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,
- }
- })
- .hi
+ .last()
+ .map_or(typaram.span, |bound| match *bound {
+ ast::RegionTyParamBound(ref lt) => lt.span,
+ ast::TraitTyParamBound(ref prt, _) => prt.span,
+ })
+ .hi
}
#[inline]
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') {
}
}
-#[inline]
-#[cfg(target_pointer_width="64")]
-// Based on the trick layed out at
-// http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-pub fn round_up_to_power_of_two(mut x: usize) -> usize {
- x = x.wrapping_sub(1);
- x |= x >> 1;
- x |= x >> 2;
- x |= x >> 4;
- x |= x >> 8;
- x |= x >> 16;
- x |= x >> 32;
- x.wrapping_add(1)
-}
-
-#[inline]
-#[cfg(target_pointer_width="32")]
-pub fn round_up_to_power_of_two(mut x: usize) -> usize {
- x = x.wrapping_sub(1);
- x |= x >> 1;
- x |= x >> 2;
- x |= x >> 4;
- x |= x >> 8;
- x |= x >> 16;
- x.wrapping_add(1)
-}
-
// Macro for deriving implementations of Decodable for enums
#[macro_export]
macro_rules! impl_enum_decodable {
}
impl ::config::ConfigType for $e {
- fn get_variant_names() -> String {
+ fn doc_hint() -> String {
let mut variants = Vec::new();
$(
variants.push(stringify!($x));
})
}
+macro_rules! msg {
+ ($($arg:tt)*) => (
+ match writeln!(&mut ::std::io::stderr(), $($arg)* ) {
+ Ok(_) => {},
+ Err(x) => panic!("Unable to write to stderr: {}", x),
+ }
+ )
+}
+
+// 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));
assert_eq!(None, binary_search(6, 100, &closure));
}
-#[test]
-fn power_rounding() {
- assert_eq!(0, round_up_to_power_of_two(0));
- assert_eq!(1, round_up_to_power_of_two(1));
- assert_eq!(64, round_up_to_power_of_two(33));
- assert_eq!(256, round_up_to_power_of_two(256));
+pub fn left_most_sub_expr(e: &ast::Expr) -> &ast::Expr {
+ match e.node {
+ ast::ExprKind::InPlace(ref e, _) |
+ ast::ExprKind::Call(ref e, _) |
+ ast::ExprKind::Binary(_, ref e, _) |
+ ast::ExprKind::Cast(ref e, _) |
+ ast::ExprKind::Type(ref e, _) |
+ ast::ExprKind::Assign(ref e, _) |
+ ast::ExprKind::AssignOp(_, ref e, _) |
+ ast::ExprKind::Field(ref e, _) |
+ ast::ExprKind::TupField(ref e, _) |
+ ast::ExprKind::Index(ref e, _) |
+ ast::ExprKind::Range(Some(ref e), _, _) |
+ ast::ExprKind::Try(ref e) => left_most_sub_expr(e),
+ _ => e,
+ }
}
projects / rust.git / blobdiff