From 2ae7b0c8983b377d1c11ab63f13acc9df0d8e745 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Sat, 27 Apr 2019 20:29:27 +0300
Subject: [PATCH 1/4] tidy: Fix false positives from long URLs
---
src/ci/docker/scripts/sccache.sh | 2 --
src/librustc/error_codes.rs | 1 -
src/librustc_typeck/error_codes.rs | 1 -
src/tools/tidy/src/style.rs | 17 +++++++++++------
4 files changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/ci/docker/scripts/sccache.sh b/src/ci/docker/scripts/sccache.sh
index e05246201dd0c..4c03419894e7c 100644
--- a/src/ci/docker/scripts/sccache.sh
+++ b/src/ci/docker/scripts/sccache.sh
@@ -1,5 +1,3 @@
-# ignore-tidy-linelength
-
set -ex
curl -fo /usr/local/bin/sccache \
diff --git a/src/librustc/error_codes.rs b/src/librustc/error_codes.rs
index f6917c45d57e8..7f68b35d014cb 100644
--- a/src/librustc/error_codes.rs
+++ b/src/librustc/error_codes.rs
@@ -1,4 +1,3 @@
-// ignore-tidy-linelength
#![allow(non_snake_case)]
// Error messages for EXXXX errors.
diff --git a/src/librustc_typeck/error_codes.rs b/src/librustc_typeck/error_codes.rs
index ba67593ce968a..fdca3230904a8 100644
--- a/src/librustc_typeck/error_codes.rs
+++ b/src/librustc_typeck/error_codes.rs
@@ -1,4 +1,3 @@
-// ignore-tidy-linelength
// ignore-tidy-filelength
#![allow(non_snake_case)]
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 599b6c676fb27..e860f2e9df0ad 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -38,7 +38,7 @@ when executed when assertions are disabled.
Use llvm::report_fatal_error for increased robustness.";
/// Parser states for `line_is_url`.
-#[derive(PartialEq)]
+#[derive(Clone, Copy, PartialEq)]
#[allow(non_camel_case_types)]
enum LIUState {
EXP_COMMENT_START,
@@ -56,11 +56,12 @@ enum LIUState {
fn line_is_url(line: &str) -> bool {
use self::LIUState::*;
let mut state: LIUState = EXP_COMMENT_START;
+ let is_url = |w: &str| w.starts_with("http://") || w.starts_with("https://");
for tok in line.split_whitespace() {
match (state, tok) {
- (EXP_COMMENT_START, "//") => state = EXP_LINK_LABEL_OR_URL,
- (EXP_COMMENT_START, "///") => state = EXP_LINK_LABEL_OR_URL,
+ (EXP_COMMENT_START, "//") |
+ (EXP_COMMENT_START, "///") |
(EXP_COMMENT_START, "//!") => state = EXP_LINK_LABEL_OR_URL,
(EXP_LINK_LABEL_OR_URL, w)
@@ -68,14 +69,18 @@ fn line_is_url(line: &str) -> bool {
=> state = EXP_URL,
(EXP_LINK_LABEL_OR_URL, w)
- if w.starts_with("http://") || w.starts_with("https://")
+ if is_url(w)
=> state = EXP_END,
(EXP_URL, w)
- if w.starts_with("http://") || w.starts_with("https://") || w.starts_with("../")
+ if is_url(w) || w.starts_with("../")
=> state = EXP_END,
- (_, _) => return false,
+ (_, w)
+ if w.len() > COLS && is_url(w)
+ => state = EXP_END,
+
+ (_, _) => {}
}
}
From b77385bfbc5a6ed034bdf782a7c76bb00a189a01 Mon Sep 17 00:00:00 2001
From: Andrew Xu <andrewxuyuan@gmail.com>
Date: Sun, 28 Apr 2019 13:28:07 +0800
Subject: [PATCH 2/4] move some functions from parser.rs to diagostics.rs
parser.rs is too big. Some functions only for error reporting and error
recovery are being moved to diagostics.rs.
---
src/libsyntax/parse/diagnostics.rs | 226 +++++++++++++++++++++++++++++
src/libsyntax/parse/mod.rs | 1 +
src/libsyntax/parse/parser.rs | 165 +--------------------
3 files changed, 230 insertions(+), 162 deletions(-)
create mode 100644 src/libsyntax/parse/diagnostics.rs
diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs
new file mode 100644
index 0000000000000..32e1ee94f0dfb
--- /dev/null
+++ b/src/libsyntax/parse/diagnostics.rs
@@ -0,0 +1,226 @@
+use crate::ast;
+use crate::ast::{Expr, ExprKind, Item, ItemKind, Pat, PatKind, QSelf, Ty, TyKind};
+use crate::parse::parser::PathStyle;
+use crate::parse::token;
+use crate::parse::PResult;
+use crate::parse::Parser;
+use crate::print::pprust;
+use crate::ptr::P;
+use crate::ThinVec;
+use errors::Applicability;
+use syntax_pos::Span;
+
+pub trait RecoverQPath: Sized + 'static {
+ const PATH_STYLE: PathStyle = PathStyle::Expr;
+ fn to_ty(&self) -> Option<P<Ty>>;
+ fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self;
+}
+
+impl RecoverQPath for Ty {
+ const PATH_STYLE: PathStyle = PathStyle::Type;
+ fn to_ty(&self) -> Option<P<Ty>> {
+ Some(P(self.clone()))
+ }
+ fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self {
+ Self {
+ span: path.span,
+ node: TyKind::Path(qself, path),
+ id: ast::DUMMY_NODE_ID,
+ }
+ }
+}
+
+impl RecoverQPath for Pat {
+ fn to_ty(&self) -> Option<P<Ty>> {
+ self.to_ty()
+ }
+ fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self {
+ Self {
+ span: path.span,
+ node: PatKind::Path(qself, path),
+ id: ast::DUMMY_NODE_ID,
+ }
+ }
+}
+
+impl RecoverQPath for Expr {
+ fn to_ty(&self) -> Option<P<Ty>> {
+ self.to_ty()
+ }
+ fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self {
+ Self {
+ span: path.span,
+ node: ExprKind::Path(qself, path),
+ attrs: ThinVec::new(),
+ id: ast::DUMMY_NODE_ID,
+ }
+ }
+}
+
+impl<'a> Parser<'a> {
+ crate fn maybe_report_ambiguous_plus(
+ &mut self,
+ allow_plus: bool,
+ impl_dyn_multi: bool,
+ ty: &Ty,
+ ) {
+ if !allow_plus && impl_dyn_multi {
+ let sum_with_parens = format!("({})", pprust::ty_to_string(&ty));
+ self.struct_span_err(ty.span, "ambiguous `+` in a type")
+ .span_suggestion(
+ ty.span,
+ "use parentheses to disambiguate",
+ sum_with_parens,
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ }
+ }
+
+ crate fn maybe_recover_from_bad_type_plus(
+ &mut self,
+ allow_plus: bool,
+ ty: &Ty,
+ ) -> PResult<'a, ()> {
+ // Do not add `+` to expected tokens.
+ if !allow_plus || !self.token.is_like_plus() {
+ return Ok(());
+ }
+
+ self.bump(); // `+`
+ let bounds = self.parse_generic_bounds(None)?;
+ let sum_span = ty.span.to(self.prev_span);
+
+ let mut err = struct_span_err!(
+ self.sess.span_diagnostic,
+ sum_span,
+ E0178,
+ "expected a path on the left-hand side of `+`, not `{}`",
+ pprust::ty_to_string(ty)
+ );
+
+ match ty.node {
+ TyKind::Rptr(ref lifetime, ref mut_ty) => {
+ let sum_with_parens = pprust::to_string(|s| {
+ use crate::print::pprust::PrintState;
+
+ s.s.word("&")?;
+ s.print_opt_lifetime(lifetime)?;
+ s.print_mutability(mut_ty.mutbl)?;
+ s.popen()?;
+ s.print_type(&mut_ty.ty)?;
+ s.print_type_bounds(" +", &bounds)?;
+ s.pclose()
+ });
+ err.span_suggestion(
+ sum_span,
+ "try adding parentheses",
+ sum_with_parens,
+ Applicability::MachineApplicable,
+ );
+ }
+ TyKind::Ptr(..) | TyKind::BareFn(..) => {
+ err.span_label(sum_span, "perhaps you forgot parentheses?");
+ }
+ _ => {
+ err.span_label(sum_span, "expected a path");
+ }
+ }
+ err.emit();
+ Ok(())
+ }
+
+ /// Try to recover from associated item paths like `[T]::AssocItem`/`(T, U)::AssocItem`.
+ /// Attempt to convert the base expression/pattern/type into a type, parse the `::AssocItem`
+ /// tail, and combine them into a `<Ty>::AssocItem` expression/pattern/type.
+ crate fn maybe_recover_from_bad_qpath<T: RecoverQPath>(
+ &mut self,
+ base: P<T>,
+ allow_recovery: bool,
+ ) -> PResult<'a, P<T>> {
+ // Do not add `::` to expected tokens.
+ if allow_recovery && self.token == token::ModSep {
+ if let Some(ty) = base.to_ty() {
+ return self.maybe_recover_from_bad_qpath_stage_2(ty.span, ty);
+ }
+ }
+ Ok(base)
+ }
+
+ /// Given an already parsed `Ty` parse the `::AssocItem` tail and
+ /// combine them into a `<Ty>::AssocItem` expression/pattern/type.
+ crate fn maybe_recover_from_bad_qpath_stage_2<T: RecoverQPath>(
+ &mut self,
+ ty_span: Span,
+ ty: P<Ty>,
+ ) -> PResult<'a, P<T>> {
+ self.expect(&token::ModSep)?;
+
+ let mut path = ast::Path {
+ segments: Vec::new(),
+ span: syntax_pos::DUMMY_SP,
+ };
+ self.parse_path_segments(&mut path.segments, T::PATH_STYLE)?;
+ path.span = ty_span.to(self.prev_span);
+
+ let ty_str = self
+ .sess
+ .source_map()
+ .span_to_snippet(ty_span)
+ .unwrap_or_else(|_| pprust::ty_to_string(&ty));
+ self.diagnostic()
+ .struct_span_err(path.span, "missing angle brackets in associated item path")
+ .span_suggestion(
+ // this is a best-effort recovery
+ path.span,
+ "try",
+ format!("<{}>::{}", ty_str, path),
+ Applicability::MaybeIncorrect,
+ )
+ .emit();
+
+ let path_span = ty_span.shrink_to_hi(); // use an empty path since `position` == 0
+ Ok(P(T::recovered(
+ Some(QSelf {
+ ty,
+ path_span,
+ position: 0,
+ }),
+ path,
+ )))
+ }
+
+ crate fn maybe_consume_incorrect_semicolon(&mut self, items: &[P<Item>]) -> bool {
+ if self.eat(&token::Semi) {
+ let mut err = self.struct_span_err(self.prev_span, "expected item, found `;`");
+ err.span_suggestion_short(
+ self.prev_span,
+ "remove this semicolon",
+ String::new(),
+ Applicability::MachineApplicable,
+ );
+ if !items.is_empty() {
+ let previous_item = &items[items.len() - 1];
+ let previous_item_kind_name = match previous_item.node {
+ // say "braced struct" because tuple-structs and
+ // braceless-empty-struct declarations do take a semicolon
+ ItemKind::Struct(..) => Some("braced struct"),
+ ItemKind::Enum(..) => Some("enum"),
+ ItemKind::Trait(..) => Some("trait"),
+ ItemKind::Union(..) => Some("union"),
+ _ => None,
+ };
+ if let Some(name) = previous_item_kind_name {
+ err.help(&format!(
+ "{} declarations are not followed by a semicolon",
+ name
+ ));
+ }
+ }
+ err.emit();
+ true
+ } else {
+ false
+ }
+ }
+}
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 371e8fe5cf66f..608d00f5548f7 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -30,6 +30,7 @@ pub mod parser;
pub mod lexer;
pub mod token;
pub mod attr;
+pub mod diagnostics;
pub mod classify;
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index a5adb37f7455c..a7d57c182fd81 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -187,41 +187,6 @@ enum PrevTokenKind {
Other,
}
-trait RecoverQPath: Sized + 'static {
- const PATH_STYLE: PathStyle = PathStyle::Expr;
- fn to_ty(&self) -> Option<P<Ty>>;
- fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self;
-}
-
-impl RecoverQPath for Ty {
- const PATH_STYLE: PathStyle = PathStyle::Type;
- fn to_ty(&self) -> Option<P<Ty>> {
- Some(P(self.clone()))
- }
- fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self {
- Self { span: path.span, node: TyKind::Path(qself, path), id: ast::DUMMY_NODE_ID }
- }
-}
-
-impl RecoverQPath for Pat {
- fn to_ty(&self) -> Option<P<Ty>> {
- self.to_ty()
- }
- fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self {
- Self { span: path.span, node: PatKind::Path(qself, path), id: ast::DUMMY_NODE_ID }
- }
-}
-
-impl RecoverQPath for Expr {
- fn to_ty(&self) -> Option<P<Ty>> {
- self.to_ty()
- }
- fn recovered(qself: Option<QSelf>, path: ast::Path) -> Self {
- Self { span: path.span, node: ExprKind::Path(qself, path),
- attrs: ThinVec::new(), id: ast::DUMMY_NODE_ID }
- }
-}
-
/* ident is handled by common.rs */
#[derive(Clone)]
@@ -1452,7 +1417,7 @@ impl<'a> Parser<'a> {
fn span_err<S: Into<MultiSpan>>(&self, sp: S, m: &str) {
self.sess.span_diagnostic.span_err(sp, m)
}
- fn struct_span_err<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> DiagnosticBuilder<'a> {
+ crate fn struct_span_err<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> DiagnosticBuilder<'a> {
self.sess.span_diagnostic.struct_span_err(sp, m)
}
crate fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> ! {
@@ -1850,99 +1815,6 @@ impl<'a> Parser<'a> {
Ok(TyKind::TraitObject(bounds, TraitObjectSyntax::None))
}
- fn maybe_report_ambiguous_plus(&mut self, allow_plus: bool, impl_dyn_multi: bool, ty: &Ty) {
- if !allow_plus && impl_dyn_multi {
- let sum_with_parens = format!("({})", pprust::ty_to_string(&ty));
- self.struct_span_err(ty.span, "ambiguous `+` in a type")
- .span_suggestion(
- ty.span,
- "use parentheses to disambiguate",
- sum_with_parens,
- Applicability::MachineApplicable
- ).emit();
- }
- }
-
- fn maybe_recover_from_bad_type_plus(&mut self, allow_plus: bool, ty: &Ty) -> PResult<'a, ()> {
- // Do not add `+` to expected tokens.
- if !allow_plus || !self.token.is_like_plus() {
- return Ok(())
- }
-
- self.bump(); // `+`
- let bounds = self.parse_generic_bounds(None)?;
- let sum_span = ty.span.to(self.prev_span);
-
- let mut err = struct_span_err!(self.sess.span_diagnostic, sum_span, E0178,
- "expected a path on the left-hand side of `+`, not `{}`", pprust::ty_to_string(ty));
-
- match ty.node {
- TyKind::Rptr(ref lifetime, ref mut_ty) => {
- let sum_with_parens = pprust::to_string(|s| {
- use crate::print::pprust::PrintState;
-
- s.s.word("&")?;
- s.print_opt_lifetime(lifetime)?;
- s.print_mutability(mut_ty.mutbl)?;
- s.popen()?;
- s.print_type(&mut_ty.ty)?;
- s.print_type_bounds(" +", &bounds)?;
- s.pclose()
- });
- err.span_suggestion(
- sum_span,
- "try adding parentheses",
- sum_with_parens,
- Applicability::MachineApplicable
- );
- }
- TyKind::Ptr(..) | TyKind::BareFn(..) => {
- err.span_label(sum_span, "perhaps you forgot parentheses?");
- }
- _ => {
- err.span_label(sum_span, "expected a path");
- },
- }
- err.emit();
- Ok(())
- }
-
- /// Try to recover from associated item paths like `[T]::AssocItem`/`(T, U)::AssocItem`.
- /// Attempt to convert the base expression/pattern/type into a type, parse the `::AssocItem`
- /// tail, and combine them into a `<Ty>::AssocItem` expression/pattern/type.
- fn maybe_recover_from_bad_qpath<T: RecoverQPath>(&mut self, base: P<T>, allow_recovery: bool)
- -> PResult<'a, P<T>> {
- // Do not add `::` to expected tokens.
- if allow_recovery && self.token == token::ModSep {
- if let Some(ty) = base.to_ty() {
- return self.maybe_recover_from_bad_qpath_stage_2(ty.span, ty);
- }
- }
- Ok(base)
- }
-
- /// Given an already parsed `Ty` parse the `::AssocItem` tail and
- /// combine them into a `<Ty>::AssocItem` expression/pattern/type.
- fn maybe_recover_from_bad_qpath_stage_2<T: RecoverQPath>(&mut self, ty_span: Span, ty: P<Ty>)
- -> PResult<'a, P<T>> {
- self.expect(&token::ModSep)?;
-
- let mut path = ast::Path { segments: Vec::new(), span: syntax_pos::DUMMY_SP };
- self.parse_path_segments(&mut path.segments, T::PATH_STYLE)?;
- path.span = ty_span.to(self.prev_span);
-
- let ty_str = self.sess.source_map().span_to_snippet(ty_span)
- .unwrap_or_else(|_| pprust::ty_to_string(&ty));
- self.diagnostic()
- .struct_span_err(path.span, "missing angle brackets in associated item path")
- .span_suggestion( // this is a best-effort recovery
- path.span, "try", format!("<{}>::{}", ty_str, path), Applicability::MaybeIncorrect
- ).emit();
-
- let path_span = ty_span.shrink_to_hi(); // use an empty path since `position` == 0
- Ok(P(T::recovered(Some(QSelf { ty, path_span, position: 0 }), path)))
- }
-
fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind> {
let opt_lifetime = if self.check_lifetime() { Some(self.expect_lifetime()) } else { None };
let mutbl = self.parse_mutability();
@@ -2377,7 +2249,7 @@ impl<'a> Parser<'a> {
self.parse_path(style)
}
- fn parse_path_segments(&mut self,
+ crate fn parse_path_segments(&mut self,
segments: &mut Vec<PathSegment>,
style: PathStyle)
-> PResult<'a, ()> {
@@ -5738,7 +5610,7 @@ impl<'a> Parser<'a> {
return Ok(bounds);
}
- fn parse_generic_bounds(&mut self, colon_span: Option<Span>) -> PResult<'a, GenericBounds> {
+ crate fn parse_generic_bounds(&mut self, colon_span: Option<Span>) -> PResult<'a, GenericBounds> {
self.parse_generic_bounds_common(true, colon_span)
}
@@ -7268,37 +7140,6 @@ impl<'a> Parser<'a> {
}
}
- fn maybe_consume_incorrect_semicolon(&mut self, items: &[P<Item>]) -> bool {
- if self.eat(&token::Semi) {
- let mut err = self.struct_span_err(self.prev_span, "expected item, found `;`");
- err.span_suggestion_short(
- self.prev_span,
- "remove this semicolon",
- String::new(),
- Applicability::MachineApplicable,
- );
- if !items.is_empty() {
- let previous_item = &items[items.len()-1];
- let previous_item_kind_name = match previous_item.node {
- // say "braced struct" because tuple-structs and
- // braceless-empty-struct declarations do take a semicolon
- ItemKind::Struct(..) => Some("braced struct"),
- ItemKind::Enum(..) => Some("enum"),
- ItemKind::Trait(..) => Some("trait"),
- ItemKind::Union(..) => Some("union"),
- _ => None,
- };
- if let Some(name) = previous_item_kind_name {
- err.help(&format!("{} declarations are not followed by a semicolon", name));
- }
- }
- err.emit();
- true
- } else {
- false
- }
- }
-
/// Given a termination token, parses all of the items in a module.
fn parse_mod_items(&mut self, term: &token::Token, inner_lo: Span) -> PResult<'a, Mod> {
let mut items = vec![];
From 52356cad4e749dd394d5f7571f4589b9d1430db5 Mon Sep 17 00:00:00 2001
From: Yuki OKUSHI <huyuumi.dev@gmail.com>
Date: Sun, 28 Apr 2019 22:54:06 +0900
Subject: [PATCH 3/4] Add test
---
src/test/ui/async-with-closure.rs | 26 ++++++++++++++++++++++++++
1 file changed, 26 insertions(+)
create mode 100644 src/test/ui/async-with-closure.rs
diff --git a/src/test/ui/async-with-closure.rs b/src/test/ui/async-with-closure.rs
new file mode 100644
index 0000000000000..856a778078a61
--- /dev/null
+++ b/src/test/ui/async-with-closure.rs
@@ -0,0 +1,26 @@
+// compile-pass
+// edition:2018
+
+#![feature(async_await, await_macro)]
+
+trait MyClosure {
+ type Args;
+}
+
+impl<R> MyClosure for dyn FnMut() -> R
+where R: 'static {
+ type Args = ();
+}
+
+struct MyStream<C: ?Sized + MyClosure> {
+ x: C::Args,
+}
+
+async fn get_future<C: ?Sized + MyClosure>(_stream: MyStream<C>) {}
+
+async fn f() {
+ let messages: MyStream<FnMut()> = unimplemented!();
+ await!(get_future(messages));
+}
+
+fn main() {}
From 4c0f01cc27a8ba8f86c7356f36bd94e437d32a39 Mon Sep 17 00:00:00 2001
From: Yuki OKUSHI <huyuumi.dev@gmail.com>
Date: Mon, 29 Apr 2019 02:33:50 +0900
Subject: [PATCH 4/4] Stabilize str::as_mut_ptr
---
src/libcore/str/mod.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 7a5511ee1dc8b..89dfa0d3e4850 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -2214,7 +2214,7 @@ impl str {
/// modified in a way that it remains valid UTF-8.
///
/// [`u8`]: primitive.u8.html
- #[unstable(feature = "str_as_mut_ptr", issue = "58215")]
+ #[stable(feature = "str_as_mut_ptr", since = "1.36.0")]
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut u8 {
self as *mut str as *mut u8