Update to latest syn-1.0.16
* fill back missing NOTICE,METADATA,*LICENSE* files
Bug: 150877376
Test: make
Test: atest --host -c --include-subdirs external/rust/crates
Change-Id: Ib5df6b8fb97764214e701a888e44fab3a4245800
diff --git a/tests/clone.sh b/tests/clone.sh
deleted file mode 100755
index 03d0c22..0000000
--- a/tests/clone.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/bash
-
-REV=7979016aff545f7b41cc517031026020b340989d
-
-set -euo pipefail
-cd "$(dirname "${BASH_SOURCE[0]}")"
-mkdir -p rust
-touch rust/COMMIT
-
-if [ "$(cat rust/COMMIT)" != "$REV" ]; then
- rm -rf rust
- mkdir rust
- curl -L "https://github.com/rust-lang/rust/archive/${REV}.tar.gz" \
- | tar xz --directory rust --strip-components 1
- echo "$REV" > rust/COMMIT
-fi
diff --git a/tests/common/eq.rs b/tests/common/eq.rs
index 199e0fe..e03b25b 100644
--- a/tests/common/eq.rs
+++ b/tests/common/eq.rs
@@ -1,36 +1,33 @@
extern crate rustc_data_structures;
+extern crate rustc_span;
extern crate rustc_target;
extern crate syntax;
-extern crate syntax_pos;
use std::mem;
use rustc_data_structures::sync::Lrc;
use rustc_data_structures::thin_vec::ThinVec;
-use rustc_target::abi::FloatTy;
-use rustc_target::spec::abi::Abi;
+use rustc_span::source_map::Spanned;
+use rustc_span::{sym, Span, Symbol, SyntaxContext, DUMMY_SP};
use syntax::ast::{
- AngleBracketedArgs, AnonConst, Arm, AsmDialect, AssocTyConstraint, AssocTyConstraintKind,
- AttrId, AttrItem, AttrStyle, Attribute, BareFnTy, BinOpKind, BindingMode, Block,
- BlockCheckMode, CaptureBy, Constness, Crate, CrateSugar, Defaultness, EnumDef, Expr, ExprKind,
- Field, FieldPat, FnDecl, FnHeader, ForeignItem, ForeignItemKind, ForeignMod, FunctionRetTy,
- GenericArg, GenericArgs, GenericBound, GenericParam, GenericParamKind, Generics, GlobalAsm,
- Ident, ImplItem, ImplItemKind, ImplPolarity, InlineAsm, InlineAsmOutput, IntTy, IsAsync,
- IsAuto, Item, ItemKind, Label, Lifetime, Lit, LitIntType, LitKind, Local, Mac, MacDelimiter,
- MacStmtStyle, MacroDef, MethodSig, Mod, Movability, MutTy, Mutability, NodeId, Param,
- ParenthesizedArgs, Pat, PatKind, Path, PathSegment, PolyTraitRef, QSelf, RangeEnd, RangeLimits,
- RangeSyntax, Stmt, StmtKind, StrStyle, StructField, TraitBoundModifier, TraitItem,
- TraitItemKind, TraitObjectSyntax, TraitRef, Ty, TyKind, UintTy, UnOp, UnsafeSource, Unsafety,
- UseTree, UseTreeKind, Variant, VariantData, VisibilityKind, WhereBoundPredicate, WhereClause,
+ AngleBracketedArgs, AnonConst, Arm, AsmDialect, AssocItem, AssocItemKind, AssocTyConstraint,
+ AssocTyConstraintKind, Async, AttrId, AttrItem, AttrKind, AttrStyle, Attribute, BareFnTy,
+ BinOpKind, BindingMode, Block, BlockCheckMode, BorrowKind, CaptureBy, Const, Crate, CrateSugar,
+ Defaultness, EnumDef, Expr, ExprKind, Extern, Field, FieldPat, FloatTy, FnDecl, FnHeader,
+ FnRetTy, FnSig, ForeignMod, GenericArg, GenericArgs, GenericBound, GenericParam,
+ GenericParamKind, Generics, GlobalAsm, Ident, ImplPolarity, InlineAsm, InlineAsmOutput, IntTy,
+ IsAuto, Item, ItemKind, Label, Lifetime, Lit, LitFloatType, LitIntType, LitKind, Local, Mac,
+ MacArgs, MacDelimiter, MacStmtStyle, MacroDef, Mod, Movability, MutTy, Mutability, NodeId,
+ Param, ParenthesizedArgs, Pat, PatKind, Path, PathSegment, PolyTraitRef, QSelf, RangeEnd,
+ RangeLimits, RangeSyntax, Stmt, StmtKind, StrLit, StrStyle, StructField, TraitBoundModifier,
+ TraitObjectSyntax, TraitRef, Ty, TyKind, UintTy, UnOp, Unsafe, UnsafeSource, UseTree,
+ UseTreeKind, Variant, VariantData, VisibilityKind, WhereBoundPredicate, WhereClause,
WhereEqPredicate, WherePredicate, WhereRegionPredicate,
};
-use syntax::parse::lexer::comments;
-use syntax::parse::token::{self, DelimToken, Token, TokenKind};
use syntax::ptr::P;
-use syntax::source_map::Spanned;
-use syntax::symbol::{sym, Symbol};
+use syntax::token::{self, DelimToken, Token, TokenKind};
use syntax::tokenstream::{DelimSpan, TokenStream, TokenTree};
-use syntax_pos::{Span, SyntaxContext, DUMMY_SP};
+use syntax::util::comments;
pub trait SpanlessEq {
fn eq(&self, other: &Self) -> bool;
@@ -127,16 +124,15 @@
spanless_eq_partial_eq!(usize);
spanless_eq_partial_eq!(char);
spanless_eq_partial_eq!(Symbol);
-spanless_eq_partial_eq!(Abi);
spanless_eq_partial_eq!(DelimToken);
macro_rules! spanless_eq_struct {
{
- $name:ident;
+ $name:ident $(<$param:ident>)?;
$([$field:ident $other:ident])*
$(![$ignore:ident])*
} => {
- impl SpanlessEq for $name {
+ impl $(<$param: SpanlessEq>)* SpanlessEq for $name $(<$param>)* {
fn eq(&self, other: &Self) -> bool {
let $name { $($field,)* $($ignore: _,)* } = self;
let $name { $($field: $other,)* $($ignore: _,)* } = other;
@@ -146,14 +142,14 @@
};
{
- $name:ident;
+ $name:ident $(<$param:ident>)?;
$([$field:ident $other:ident])*
$next:ident
$($rest:ident)*
$(!$ignore:ident)*
} => {
spanless_eq_struct! {
- $name;
+ $name $(<$param>)*;
$([$field $other])*
[$next other]
$($rest)*
@@ -162,14 +158,14 @@
};
{
- $name:ident;
+ $name:ident $(<$param:ident>)?;
$([$field:ident $other:ident])*
$(![$ignore:ident])*
!$next:ident
$(!$rest:ident)*
} => {
spanless_eq_struct! {
- $name;
+ $name $(<$param>)*;
$([$field $other])*
$(![$ignore])*
![$next]
@@ -266,34 +262,33 @@
spanless_eq_struct!(AngleBracketedArgs; span args constraints);
spanless_eq_struct!(AnonConst; id value);
spanless_eq_struct!(Arm; attrs pat guard body span id is_placeholder);
+spanless_eq_struct!(AssocItem; attrs id span vis ident defaultness kind !tokens);
spanless_eq_struct!(AssocTyConstraint; id ident kind span);
-spanless_eq_struct!(AttrItem; path tokens);
-spanless_eq_struct!(Attribute; item id style span !is_sugared_doc);
-spanless_eq_struct!(BareFnTy; unsafety abi generic_params decl);
+spanless_eq_struct!(AttrItem; path args);
+spanless_eq_struct!(Attribute; kind id style span);
+spanless_eq_struct!(BareFnTy; unsafety ext generic_params decl);
spanless_eq_struct!(Block; stmts id rules span);
-spanless_eq_struct!(Crate; module attrs span);
+spanless_eq_struct!(Crate; module attrs span proc_macros);
spanless_eq_struct!(EnumDef; variants);
spanless_eq_struct!(Expr; id kind span attrs);
-spanless_eq_struct!(Field; ident expr span is_shorthand attrs id is_placeholder);
+spanless_eq_struct!(Field; attrs id span ident expr is_shorthand is_placeholder);
spanless_eq_struct!(FieldPat; ident pat is_shorthand attrs id span is_placeholder);
spanless_eq_struct!(FnDecl; inputs output);
-spanless_eq_struct!(FnHeader; constness asyncness unsafety abi);
-spanless_eq_struct!(ForeignItem; ident attrs kind id span vis);
+spanless_eq_struct!(FnHeader; constness asyncness unsafety ext);
+spanless_eq_struct!(FnSig; header decl);
spanless_eq_struct!(ForeignMod; abi items);
spanless_eq_struct!(GenericParam; id ident attrs bounds is_placeholder kind);
spanless_eq_struct!(Generics; params where_clause span);
spanless_eq_struct!(GlobalAsm; asm);
-spanless_eq_struct!(ImplItem; id ident vis defaultness attrs generics kind span !tokens);
spanless_eq_struct!(InlineAsm; asm asm_str_style outputs inputs clobbers volatile alignstack dialect);
spanless_eq_struct!(InlineAsmOutput; constraint expr is_rw is_indirect);
-spanless_eq_struct!(Item; ident attrs id kind vis span !tokens);
+spanless_eq_struct!(Item<K>; attrs id span vis ident kind !tokens);
spanless_eq_struct!(Label; ident);
spanless_eq_struct!(Lifetime; id ident);
spanless_eq_struct!(Lit; token kind span);
spanless_eq_struct!(Local; pat ty init id span attrs);
-spanless_eq_struct!(Mac; path delim tts span prior_type_ascription);
-spanless_eq_struct!(MacroDef; tokens legacy);
-spanless_eq_struct!(MethodSig; header decl);
+spanless_eq_struct!(Mac; path args prior_type_ascription);
+spanless_eq_struct!(MacroDef; body legacy);
spanless_eq_struct!(Mod; inner items inline);
spanless_eq_struct!(MutTy; ty mutbl);
spanless_eq_struct!(Param; attrs ty pat id span is_placeholder);
@@ -304,56 +299,59 @@
spanless_eq_struct!(PolyTraitRef; bound_generic_params trait_ref span);
spanless_eq_struct!(QSelf; ty path_span position);
spanless_eq_struct!(Stmt; id kind span);
-spanless_eq_struct!(StructField; span ident vis id ty attrs is_placeholder);
+spanless_eq_struct!(StrLit; style symbol suffix span symbol_unescaped);
+spanless_eq_struct!(StructField; attrs id span vis ident ty is_placeholder);
spanless_eq_struct!(Token; kind span);
-spanless_eq_struct!(TraitItem; id ident attrs generics kind span !tokens);
spanless_eq_struct!(TraitRef; path ref_id);
spanless_eq_struct!(Ty; id kind span);
spanless_eq_struct!(UseTree; prefix kind span);
-spanless_eq_struct!(Variant; ident attrs id data disr_expr span is_placeholder);
+spanless_eq_struct!(Variant; attrs id span vis ident data disr_expr is_placeholder);
spanless_eq_struct!(WhereBoundPredicate; span bound_generic_params bounded_ty bounds);
spanless_eq_struct!(WhereClause; predicates span);
spanless_eq_struct!(WhereEqPredicate; id span lhs_ty rhs_ty);
spanless_eq_struct!(WhereRegionPredicate; span lifetime bounds);
spanless_eq_enum!(AsmDialect; Att Intel);
+spanless_eq_enum!(AssocItemKind; Const(0 1) Static(0 1 2) Fn(0 1 2) TyAlias(0 1 2) Macro(0));
spanless_eq_enum!(AssocTyConstraintKind; Equality(ty) Bound(bounds));
+spanless_eq_enum!(Async; Yes(span closure_id return_impl_trait_id) No);
+spanless_eq_enum!(AttrKind; Normal(0) DocComment(0));
spanless_eq_enum!(AttrStyle; Outer Inner);
spanless_eq_enum!(BinOpKind; Add Sub Mul Div Rem And Or BitXor BitAnd BitOr Shl Shr Eq Lt Le Ne Ge Gt);
spanless_eq_enum!(BindingMode; ByRef(0) ByValue(0));
spanless_eq_enum!(BlockCheckMode; Default Unsafe(0));
+spanless_eq_enum!(BorrowKind; Ref Raw);
spanless_eq_enum!(CaptureBy; Value Ref);
-spanless_eq_enum!(Constness; Const NotConst);
+spanless_eq_enum!(Const; Yes(0) No);
spanless_eq_enum!(CrateSugar; PubCrate JustCrate);
spanless_eq_enum!(Defaultness; Default Final);
+spanless_eq_enum!(Extern; None Implicit Explicit(0));
spanless_eq_enum!(FloatTy; F32 F64);
-spanless_eq_enum!(ForeignItemKind; Fn(0 1) Static(0 1) Ty Macro(0));
-spanless_eq_enum!(FunctionRetTy; Default(0) Ty(0));
+spanless_eq_enum!(FnRetTy; Default(0) Ty(0));
spanless_eq_enum!(GenericArg; Lifetime(0) Type(0) Const(0));
spanless_eq_enum!(GenericArgs; AngleBracketed(0) Parenthesized(0));
spanless_eq_enum!(GenericBound; Trait(0 1) Outlives(0));
spanless_eq_enum!(GenericParamKind; Lifetime Type(default) Const(ty));
-spanless_eq_enum!(ImplItemKind; Const(0 1) Method(0 1) TyAlias(0) OpaqueTy(0) Macro(0));
spanless_eq_enum!(ImplPolarity; Positive Negative);
spanless_eq_enum!(IntTy; Isize I8 I16 I32 I64 I128);
-spanless_eq_enum!(IsAsync; Async(closure_id return_impl_trait_id) NotAsync);
spanless_eq_enum!(IsAuto; Yes No);
+spanless_eq_enum!(LitFloatType; Suffixed(0) Unsuffixed);
spanless_eq_enum!(LitIntType; Signed(0) Unsigned(0) Unsuffixed);
+spanless_eq_enum!(MacArgs; Empty Delimited(0 1 2) Eq(0 1));
spanless_eq_enum!(MacDelimiter; Parenthesis Bracket Brace);
spanless_eq_enum!(MacStmtStyle; Semicolon Braces NoBraces);
spanless_eq_enum!(Movability; Static Movable);
-spanless_eq_enum!(Mutability; Mutable Immutable);
+spanless_eq_enum!(Mutability; Mut Not);
spanless_eq_enum!(RangeEnd; Included(0) Excluded);
spanless_eq_enum!(RangeLimits; HalfOpen Closed);
spanless_eq_enum!(StmtKind; Local(0) Item(0) Expr(0) Semi(0) Mac(0));
spanless_eq_enum!(StrStyle; Cooked Raw(0));
spanless_eq_enum!(TokenTree; Token(0) Delimited(0 1 2));
-spanless_eq_enum!(TraitBoundModifier; None Maybe);
-spanless_eq_enum!(TraitItemKind; Const(0 1) Method(0 1) Type(0 1) Macro(0));
+spanless_eq_enum!(TraitBoundModifier; None Maybe MaybeConst MaybeConstMaybe);
spanless_eq_enum!(TraitObjectSyntax; Dyn None);
spanless_eq_enum!(UintTy; Usize U8 U16 U32 U64 U128);
spanless_eq_enum!(UnOp; Deref Not Neg);
+spanless_eq_enum!(Unsafe; Yes(0) No);
spanless_eq_enum!(UnsafeSource; CompilerGenerated UserProvided);
-spanless_eq_enum!(Unsafety; Unsafe Normal);
spanless_eq_enum!(UseTreeKind; Simple(0 1 2) Nested(0) Glob);
spanless_eq_enum!(VariantData; Struct(0 1) Tuple(0 1) Unit(0));
spanless_eq_enum!(VisibilityKind; Public Crate(0) Restricted(path id) Inherited);
@@ -361,16 +359,17 @@
spanless_eq_enum!(ExprKind; Box(0) Array(0) Call(0 1) MethodCall(0 1) Tup(0)
Binary(0 1 2) Unary(0 1) Lit(0) Cast(0 1) Type(0 1) Let(0 1) If(0 1 2)
While(0 1 2) ForLoop(0 1 2 3) Loop(0 1) Match(0 1) Closure(0 1 2 3 4 5)
- Block(0 1) Async(0 1 2) Await(0) TryBlock(0) Assign(0 1) AssignOp(0 1 2)
- Field(0 1) Index(0 1) Range(0 1 2) Path(0 1) AddrOf(0 1) Break(0 1)
+ Block(0 1) Async(0 1 2) Await(0) TryBlock(0) Assign(0 1 2) AssignOp(0 1 2)
+ Field(0 1) Index(0 1) Range(0 1 2) Path(0 1) AddrOf(0 1 2) Break(0 1)
Continue(0) Ret(0) InlineAsm(0) Mac(0) Struct(0 1 2) Repeat(0 1) Paren(0)
Try(0) Yield(0) Err);
spanless_eq_enum!(ItemKind; ExternCrate(0) Use(0) Static(0 1 2) Const(0 1)
- Fn(0 1 2 3) Mod(0) ForeignMod(0) GlobalAsm(0) TyAlias(0 1) OpaqueTy(0 1)
- Enum(0 1) Struct(0 1) Union(0 1) Trait(0 1 2 3 4) TraitAlias(0 1)
- Impl(0 1 2 3 4 5 6) Mac(0) MacroDef(0));
+ Fn(0 1 2) Mod(0) ForeignMod(0) GlobalAsm(0) TyAlias(0 1 2) Enum(0 1)
+ Struct(0 1) Union(0 1) Trait(0 1 2 3 4) TraitAlias(0 1)
+ Impl(unsafety polarity defaultness constness generics of_trait self_ty items)
+ Mac(0) MacroDef(0));
spanless_eq_enum!(LitKind; Str(0 1) ByteStr(0) Byte(0) Char(0) Int(0 1)
- Float(0 1) FloatUnsuffixed(0) Bool(0) Err(0));
+ Float(0 1) Bool(0) Err(0));
spanless_eq_enum!(PatKind; Wild Ident(0 1 2) Struct(0 1 2) TupleStruct(0 1)
Or(0) Path(0 1) Tuple(0) Box(0) Ref(0 1) Lit(0) Range(0 1 2) Slice(0) Rest
Paren(0) Mac(0));
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index 8b784be..3dd2552 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -12,3 +12,8 @@
Err(_) => usize::max_value(),
}
}
+
+/// Are we running in travis-ci.org.
+pub fn travis_ci() -> bool {
+ env::var_os("TRAVIS").is_some()
+}
diff --git a/tests/common/parse.rs b/tests/common/parse.rs
index e6425b7..acdd172 100644
--- a/tests/common/parse.rs
+++ b/tests/common/parse.rs
@@ -1,19 +1,20 @@
+extern crate rustc_expand;
+extern crate rustc_parse as parse;
+extern crate rustc_session;
+extern crate rustc_span;
extern crate syntax;
-extern crate syntax_pos;
+use rustc_session::parse::ParseSess;
+use rustc_span::source_map::FilePathMapping;
+use rustc_span::FileName;
use syntax::ast;
-use syntax::parse;
use syntax::ptr::P;
-use syntax::sess::ParseSess;
-use syntax::source_map::FilePathMapping;
-use syntax_pos::FileName;
use std::panic;
pub fn libsyntax_expr(input: &str) -> Option<P<ast::Expr>> {
match panic::catch_unwind(|| {
let sess = ParseSess::new(FilePathMapping::empty());
- sess.span_diagnostic.set_continue_after_error(false);
let e = parse::new_parser_from_source_str(
&sess,
FileName::Custom("test_precedence".to_string()),
diff --git a/tests/repo/mod.rs b/tests/repo/mod.rs
index 02b4e32..6ab8d2e 100644
--- a/tests/repo/mod.rs
+++ b/tests/repo/mod.rs
@@ -1,7 +1,16 @@
-use std::process::Command;
+mod progress;
+use self::progress::Progress;
+use crate::common;
+use anyhow::Result;
+use flate2::read::GzDecoder;
+use std::fs;
+use std::path::Path;
+use tar::Archive;
use walkdir::DirEntry;
+const REVISION: &str = "2c462a2f776b899d46743b1b44eda976e846e61d";
+
pub fn base_dir_filter(entry: &DirEntry) -> bool {
let path = entry.path();
if path.is_dir() {
@@ -10,51 +19,159 @@
if path.extension().map(|e| e != "rs").unwrap_or(true) {
return false;
}
- let path_string = path.to_string_lossy();
- let path_string = if cfg!(windows) {
- path_string.replace('\\', "/").into()
- } else {
- path_string
- };
+
+ let mut path_string = path.to_string_lossy();
+ if cfg!(windows) {
+ path_string = path_string.replace('\\', "/").into();
+ }
+ assert!(path_string.starts_with("tests/rust/src/"));
+ let path = &path_string["tests/rust/src/".len()..];
+
// TODO assert that parsing fails on the parse-fail cases
- if path_string.starts_with("tests/rust/src/test/parse-fail")
- || path_string.starts_with("tests/rust/src/test/compile-fail")
- || path_string.starts_with("tests/rust/src/test/rustfix")
+ if path.starts_with("test/parse-fail")
+ || path.starts_with("test/compile-fail")
+ || path.starts_with("test/rustfix")
{
return false;
}
- if path_string.starts_with("tests/rust/src/test/ui") {
- let stderr_path = path.with_extension("stderr");
+ if path.starts_with("test/ui") {
+ let stderr_path = entry.path().with_extension("stderr");
if stderr_path.exists() {
// Expected to fail in some way
return false;
}
}
- match path_string.as_ref() {
+ match path {
+ // TODO: or-patterns patterns: `Some(1 | 8)`
+ // https://github.com/dtolnay/syn/issues/758
+ "test/mir-opt/exponential-or.rs" |
+ "test/ui/or-patterns/basic-switch.rs" |
+ "test/ui/or-patterns/basic-switchint.rs" |
+ "test/ui/or-patterns/bindings-runpass-1.rs" |
+ "test/ui/or-patterns/bindings-runpass-2.rs" |
+ "test/ui/or-patterns/consistent-bindings.rs" |
+ "test/ui/or-patterns/exhaustiveness-pass.rs" |
+ "test/ui/or-patterns/for-loop.rs" |
+ "test/ui/or-patterns/if-let-while-let.rs" |
+ "test/ui/or-patterns/issue-67514-irrefutable-param.rs" |
+ "test/ui/or-patterns/issue-68785-irrefutable-param-with-at.rs" |
+ "test/ui/or-patterns/let-pattern.rs" |
+ "test/ui/or-patterns/mix-with-wild.rs" |
+ "test/ui/or-patterns/or-patterns-default-binding-modes.rs" |
+ "test/ui/or-patterns/or-patterns-syntactic-pass.rs" |
+ "test/ui/or-patterns/search-via-bindings.rs" |
+ "test/ui/or-patterns/struct-like.rs" |
+
+ // TODO: inner attr in traits: `trait Foo { #![...] }`
+ // https://github.com/dtolnay/syn/issues/759
+ "test/pretty/trait-inner-attr.rs" |
+ "test/ui/parser/inner-attr-in-trait-def.rs" |
+
+ // TODO: const underscore in traits: `trait A { const _: (); }`
+ // https://github.com/dtolnay/syn/issues/760
+ "test/ui/parser/assoc-const-underscore-syntactic-pass.rs" |
+
+ // TODO: top level fn without body: `fn f();`
+ // https://github.com/dtolnay/syn/issues/761
+ "test/ui/parser/fn-body-optional-syntactic-pass.rs" |
+ "test/ui/parser/fn-header-syntactic-pass.rs" |
+
+ // TODO: extern static with value: `extern { static X: u8 = 0; }`
+ // https://github.com/dtolnay/syn/issues/762
+ "test/ui/parser/foreign-static-syntactic-pass.rs" |
+
+ // TODO: extern type with bound: `extern { type A: Ord; }`
+ // https://github.com/dtolnay/syn/issues/763
+ "test/ui/parser/foreign-ty-syntactic-pass.rs" |
+
+ // TODO: top level const/static without value: `const X: u8;`
+ // https://github.com/dtolnay/syn/issues/764
+ "test/ui/parser/item-free-const-no-body-syntactic-pass.rs" |
+ "test/ui/parser/item-free-static-no-body-syntactic-pass.rs" |
+
+ // TODO: mut receiver in fn pointer type: `fn(mut self)`
+ // https://github.com/dtolnay/syn/issues/765
+ "test/ui/parser/self-param-syntactic-pass.rs" |
+
+ // TODO: const trait impls and bounds
+ // https://github.com/dtolnay/syn/issues/766
+ // https://github.com/dtolnay/syn/issues/767
+ "test/ui/rfc-2632-const-trait-impl/assoc-type.rs" |
+ "test/ui/rfc-2632-const-trait-impl/call-const-trait-method-pass.rs" |
+ "test/ui/rfc-2632-const-trait-impl/const-trait-bound-opt-out/feature-gate.rs" |
+ "test/ui/rfc-2632-const-trait-impl/const-trait-bound-opt-out/syntax.rs" |
+ "test/ui/rfc-2632-const-trait-impl/feature-gate.rs" |
+ "test/ui/rfc-2632-const-trait-impl/generic-bound.rs" |
+ "test/ui/rfc-2632-const-trait-impl/syntax.rs" |
+
// Deprecated placement syntax
- "tests/rust/src/test/ui/obsolete-in-place/bad.rs" |
+ "test/ui/obsolete-in-place/bad.rs" |
+
// Deprecated anonymous parameter syntax in traits
- "tests/rust/src/test/ui/error-codes/e0119/auxiliary/issue-23563-a.rs" |
- "tests/rust/src/test/ui/issues/issue-13105.rs" |
- "tests/rust/src/test/ui/issues/issue-13775.rs" |
- "tests/rust/src/test/ui/issues/issue-34074.rs" |
- // Deprecated await macro syntax
- "tests/rust/src/test/ui/async-await/await-macro.rs" |
+ "test/ui/error-codes/e0119/auxiliary/issue-23563-a.rs" |
+ "test/ui/issues/issue-13105.rs" |
+ "test/ui/issues/issue-13775.rs" |
+ "test/ui/issues/issue-34074.rs" |
+
// 2015-style dyn that libsyntax rejects
- "tests/rust/src/test/ui/dyn-keyword/dyn-2015-no-warnings-without-lints.rs" |
+ "test/ui/dyn-keyword/dyn-2015-no-warnings-without-lints.rs" |
+
// not actually test cases
- "tests/rust/src/test/ui/include-single-expr-helper.rs" |
- "tests/rust/src/test/ui/include-single-expr-helper-1.rs" |
- "tests/rust/src/test/ui/issues/auxiliary/issue-21146-inc.rs" |
- "tests/rust/src/test/ui/macros/auxiliary/macro-comma-support.rs" |
- "tests/rust/src/test/ui/macros/auxiliary/macro-include-items-expr.rs" => false,
+ "test/rustdoc-ui/test-compile-fail2.rs" |
+ "test/rustdoc-ui/test-compile-fail3.rs" |
+ "test/ui/include-single-expr-helper.rs" |
+ "test/ui/include-single-expr-helper-1.rs" |
+ "test/ui/issues/auxiliary/issue-21146-inc.rs" |
+ "test/ui/macros/auxiliary/macro-comma-support.rs" |
+ "test/ui/macros/auxiliary/macro-include-items-expr.rs" => false,
+
_ => true,
}
}
pub fn clone_rust() {
- let result = Command::new("tests/clone.sh").status().unwrap();
- assert!(result.success());
+ let needs_clone = match fs::read_to_string("tests/rust/COMMIT") {
+ Err(_) => true,
+ Ok(contents) => contents.trim() != REVISION,
+ };
+ if needs_clone {
+ download_and_unpack().unwrap();
+ }
+}
+
+fn download_and_unpack() -> Result<()> {
+ let url = format!(
+ "https://github.com/rust-lang/rust/archive/{}.tar.gz",
+ REVISION
+ );
+ let response = reqwest::blocking::get(&url)?.error_for_status()?;
+ let progress = Progress::new(response);
+ let decoder = GzDecoder::new(progress);
+ let mut archive = Archive::new(decoder);
+ let prefix = format!("rust-{}", REVISION);
+
+ let tests_rust = Path::new("tests/rust");
+ if tests_rust.exists() {
+ fs::remove_dir_all(tests_rust)?;
+ }
+
+ for entry in archive.entries()? {
+ let mut entry = entry?;
+ let path = entry.path()?;
+ if path == Path::new("pax_global_header") {
+ continue;
+ }
+ let relative = path.strip_prefix(&prefix)?;
+ let out = tests_rust.join(relative);
+ entry.unpack(&out)?;
+ if common::travis_ci() {
+ // Something about this makes the travis build not deadlock...
+ errorf!(".");
+ }
+ }
+
+ fs::write("tests/rust/COMMIT", REVISION)?;
+ Ok(())
}
diff --git a/tests/repo/progress.rs b/tests/repo/progress.rs
new file mode 100644
index 0000000..28c8a44
--- /dev/null
+++ b/tests/repo/progress.rs
@@ -0,0 +1,37 @@
+use std::io::{Read, Result};
+use std::time::{Duration, Instant};
+
+pub struct Progress<R> {
+ bytes: usize,
+ tick: Instant,
+ stream: R,
+}
+
+impl<R> Progress<R> {
+ pub fn new(stream: R) -> Self {
+ Progress {
+ bytes: 0,
+ tick: Instant::now() + Duration::from_millis(2000),
+ stream,
+ }
+ }
+}
+
+impl<R: Read> Read for Progress<R> {
+ fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+ let num = self.stream.read(buf)?;
+ self.bytes += num;
+ let now = Instant::now();
+ if now > self.tick {
+ self.tick = now + Duration::from_millis(500);
+ errorf!("downloading... {} bytes\n", self.bytes);
+ }
+ Ok(num)
+ }
+}
+
+impl<R> Drop for Progress<R> {
+ fn drop(&mut self) {
+ errorf!("done ({} bytes)\n", self.bytes);
+ }
+}
diff --git a/tests/test_attribute.rs b/tests/test_attribute.rs
index d77c0c0..e1b0142 100644
--- a/tests/test_attribute.rs
+++ b/tests/test_attribute.rs
@@ -286,6 +286,48 @@
"###);
}
+#[test]
+fn test_negative_lit() {
+ let meta = test("#[form(min = -1, max = 200)]");
+
+ snapshot!(meta, @r###"
+ Meta::List {
+ path: Path {
+ segments: [
+ PathSegment {
+ ident: "form",
+ arguments: None,
+ },
+ ],
+ },
+ nested: [
+ Meta(Meta::NameValue {
+ path: Path {
+ segments: [
+ PathSegment {
+ ident: "min",
+ arguments: None,
+ },
+ ],
+ },
+ lit: -1,
+ }),
+ Meta(Meta::NameValue {
+ path: Path {
+ segments: [
+ PathSegment {
+ ident: "max",
+ arguments: None,
+ },
+ ],
+ },
+ lit: 200,
+ }),
+ ],
+ }
+ "###);
+}
+
fn test(input: &str) -> Meta {
let attrs = Attribute::parse_outer.parse_str(input).unwrap();
diff --git a/tests/test_lit.rs b/tests/test_lit.rs
index 0b300c4..d4495ce 100644
--- a/tests/test_lit.rs
+++ b/tests/test_lit.rs
@@ -1,9 +1,9 @@
mod features;
-use proc_macro2::{TokenStream, TokenTree};
+use proc_macro2::{Span, TokenStream, TokenTree};
use quote::ToTokens;
use std::str::FromStr;
-use syn::Lit;
+use syn::{Lit, LitFloat, LitInt};
fn lit(s: &str) -> Lit {
match TokenStream::from_str(s)
@@ -182,3 +182,16 @@
test_float("1.0__3e-12", 1.03e-12, "");
test_float("1.03e+12", 1.03e12, "");
}
+
+#[test]
+fn negative() {
+ let span = Span::call_site();
+ assert_eq!("-1", LitInt::new("-1", span).to_string());
+ assert_eq!("-1i8", LitInt::new("-1i8", span).to_string());
+ assert_eq!("-1i16", LitInt::new("-1i16", span).to_string());
+ assert_eq!("-1i32", LitInt::new("-1i32", span).to_string());
+ assert_eq!("-1i64", LitInt::new("-1i64", span).to_string());
+ assert_eq!("-1.5", LitFloat::new("-1.5", span).to_string());
+ assert_eq!("-1.5f32", LitFloat::new("-1.5f32", span).to_string());
+ assert_eq!("-1.5f64", LitFloat::new("-1.5f64", span).to_string());
+}
diff --git a/tests/test_precedence.rs b/tests/test_precedence.rs
index 582c0fd..80f5130 100644
--- a/tests/test_precedence.rs
+++ b/tests/test_precedence.rs
@@ -15,19 +15,17 @@
//! 5. Compare the expressions with one another, if they are not equal fail.
extern crate rustc_data_structures;
-extern crate smallvec;
+extern crate rustc_span;
extern crate syntax;
-extern crate syntax_pos;
mod features;
use quote::quote;
use rayon::iter::{IntoParallelIterator, ParallelIterator};
use regex::Regex;
-use smallvec::smallvec;
+use rustc_span::edition::Edition;
use syntax::ast;
use syntax::ptr::P;
-use syntax_pos::edition::Edition;
use walkdir::{DirEntry, WalkDir};
use std::fs::File;
@@ -86,7 +84,6 @@
/// Test expressions from rustc, like in `test_round_trip`.
#[test]
-#[cfg_attr(target_os = "windows", ignore = "requires nix .sh")]
fn test_rustc_precedence() {
repo::clone_rust();
let abort_after = common::abort_after();
@@ -212,16 +209,58 @@
/// This method operates on libsyntax objects.
fn libsyntax_brackets(mut libsyntax_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
use rustc_data_structures::thin_vec::ThinVec;
- use smallvec::SmallVec;
+ use rustc_span::DUMMY_SP;
use std::mem;
- use syntax::ast::{Expr, ExprKind, Field, Mac, Pat, Stmt, StmtKind, Ty};
- use syntax::mut_visit::{noop_visit_expr, MutVisitor};
- use syntax_pos::DUMMY_SP;
+ use syntax::ast::{Block, BorrowKind, Expr, ExprKind, Field, Mac, Pat, Stmt, StmtKind, Ty};
+ use syntax::mut_visit::MutVisitor;
+ use syntax::util::map_in_place::MapInPlace;
struct BracketsVisitor {
failed: bool,
};
+ fn flat_map_field<T: MutVisitor>(mut f: Field, vis: &mut T) -> Vec<Field> {
+ if f.is_shorthand {
+ noop_visit_expr(&mut f.expr, vis);
+ } else {
+ vis.visit_expr(&mut f.expr);
+ }
+ vec![f]
+ }
+
+ fn flat_map_stmt<T: MutVisitor>(stmt: Stmt, vis: &mut T) -> Vec<Stmt> {
+ let kind = match stmt.kind {
+ // Don't wrap toplevel expressions in statements.
+ StmtKind::Expr(mut e) => {
+ noop_visit_expr(&mut e, vis);
+ StmtKind::Expr(e)
+ }
+ StmtKind::Semi(mut e) => {
+ noop_visit_expr(&mut e, vis);
+ StmtKind::Semi(e)
+ }
+ s => s,
+ };
+
+ vec![Stmt { kind, ..stmt }]
+ }
+
+ fn noop_visit_expr<T: MutVisitor>(e: &mut Expr, vis: &mut T) {
+ use syntax::mut_visit::{noop_visit_expr, visit_opt, visit_thin_attrs};
+ match &mut e.kind {
+ ExprKind::AddrOf(BorrowKind::Raw, ..) => {}
+ ExprKind::Struct(path, fields, expr) => {
+ vis.visit_path(path);
+ fields.flat_map_in_place(|field| flat_map_field(field, vis));
+ visit_opt(expr, |expr| vis.visit_expr(expr));
+ vis.visit_id(&mut e.id);
+ vis.visit_span(&mut e.span);
+ visit_thin_attrs(&mut e.attrs, vis);
+ }
+ _ => noop_visit_expr(e, vis),
+ }
+ }
+
impl MutVisitor for BracketsVisitor {
fn visit_expr(&mut self, e: &mut P<Expr>) {
noop_visit_expr(e, self);
@@ -242,13 +281,12 @@
}
}
- fn flat_map_field(&mut self, mut f: Field) -> SmallVec<[Field; 1]> {
- if f.is_shorthand {
- noop_visit_expr(&mut f.expr, self);
- } else {
- self.visit_expr(&mut f.expr);
- }
- SmallVec::from([f])
+ fn visit_block(&mut self, block: &mut P<Block>) {
+ self.visit_id(&mut block.id);
+ block
+ .stmts
+ .flat_map_in_place(|stmt| flat_map_stmt(stmt, self));
+ self.visit_span(&mut block.span);
}
// We don't want to look at expressions that might appear in patterns or
@@ -262,23 +300,6 @@
let _ = ty;
}
- fn flat_map_stmt(&mut self, stmt: Stmt) -> SmallVec<[Stmt; 1]> {
- let kind = match stmt.kind {
- // Don't wrap toplevel expressions in statements.
- StmtKind::Expr(mut e) => {
- noop_visit_expr(&mut e, self);
- StmtKind::Expr(e)
- }
- StmtKind::Semi(mut e) => {
- noop_visit_expr(&mut e, self);
- StmtKind::Semi(e)
- }
- s => s,
- };
-
- smallvec![Stmt { kind, ..stmt }]
- }
-
fn visit_mac(&mut self, mac: &mut Mac) {
// By default when folding over macros, libsyntax panics. This is
// because it's usually not what you want, you want to run after
@@ -355,7 +376,10 @@
struct CollectExprs(Vec<Expr>);
impl Fold for CollectExprs {
fn fold_expr(&mut self, expr: Expr) -> Expr {
- self.0.push(expr);
+ match expr {
+ Expr::Verbatim(tokens) if tokens.is_empty() => {}
+ _ => self.0.push(expr),
+ }
Expr::Tuple(ExprTuple {
attrs: vec![],
diff --git a/tests/test_round_trip.rs b/tests/test_round_trip.rs
index b6e8ee1..a7e48c8 100644
--- a/tests/test_round_trip.rs
+++ b/tests/test_round_trip.rs
@@ -2,19 +2,23 @@
#![recursion_limit = "1024"]
#![feature(rustc_private)]
+extern crate rustc_errors;
+extern crate rustc_expand;
+extern crate rustc_parse as parse;
+extern crate rustc_session;
+extern crate rustc_span;
extern crate syntax;
-extern crate syntax_pos;
mod features;
use quote::quote;
use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use rustc_errors::PResult;
+use rustc_session::parse::ParseSess;
+use rustc_span::edition::Edition;
+use rustc_span::source_map::FilePathMapping;
+use rustc_span::FileName;
use syntax::ast;
-use syntax::parse::{self, PResult};
-use syntax::sess::ParseSess;
-use syntax::source_map::FilePathMapping;
-use syntax_pos::edition::Edition;
-use syntax_pos::FileName;
use walkdir::{DirEntry, WalkDir};
use std::fs::File;
@@ -35,7 +39,6 @@
use common::eq::SpanlessEq;
#[test]
-#[cfg_attr(target_os = "windows", ignore = "requires nix .sh")]
fn test_round_trip() {
repo::clone_rust();
let abort_after = common::abort_after();
diff --git a/tests/test_stmt.rs b/tests/test_stmt.rs
new file mode 100644
index 0000000..d68b47f
--- /dev/null
+++ b/tests/test_stmt.rs
@@ -0,0 +1,44 @@
+#[macro_use]
+mod macros;
+
+use syn::Stmt;
+
+#[test]
+fn test_raw_operator() {
+ let stmt = syn::parse_str::<Stmt>("let _ = &raw const x;").unwrap();
+
+ snapshot!(stmt, @r###"
+ Local(Local {
+ pat: Pat::Wild,
+ init: Some(Verbatim(`& raw const x`)),
+ })
+ "###);
+}
+
+#[test]
+fn test_raw_variable() {
+ let stmt = syn::parse_str::<Stmt>("let _ = &raw;").unwrap();
+
+ snapshot!(stmt, @r###"
+ Local(Local {
+ pat: Pat::Wild,
+ init: Some(Expr::Reference {
+ expr: Expr::Path {
+ path: Path {
+ segments: [
+ PathSegment {
+ ident: "raw",
+ arguments: None,
+ },
+ ],
+ },
+ },
+ }),
+ })
+ "###);
+}
+
+#[test]
+fn test_raw_invalid() {
+ assert!(syn::parse_str::<Stmt>("let _ = &raw x;").is_err());
+}
diff --git a/tests/test_visibility.rs b/tests/test_visibility.rs
new file mode 100644
index 0000000..21c49c9
--- /dev/null
+++ b/tests/test_visibility.rs
@@ -0,0 +1,99 @@
+mod features;
+
+use proc_macro2::TokenStream;
+use syn::parse::{Parse, ParseStream};
+use syn::{Result, Visibility};
+
+#[derive(Debug)]
+struct VisRest {
+ vis: Visibility,
+ rest: TokenStream,
+}
+
+impl Parse for VisRest {
+ fn parse(input: ParseStream) -> Result<Self> {
+ Ok(VisRest {
+ vis: input.parse()?,
+ rest: input.parse()?,
+ })
+ }
+}
+
+macro_rules! assert_vis_parse {
+ ($input:expr, Ok($p:pat)) => {
+ assert_vis_parse!($input, Ok($p) + "");
+ };
+
+ ($input:expr, Ok($p:pat) + $rest:expr) => {
+ let expected = $rest.parse::<TokenStream>().unwrap();
+ let parse: VisRest = syn::parse_str($input).unwrap();
+
+ match parse.vis {
+ $p => {}
+ _ => panic!("Expected {}, got {:?}", stringify!($p), parse.vis),
+ }
+
+ // NOTE: Round-trips through `to_string` to avoid potential whitespace
+ // diffs.
+ assert_eq!(parse.rest.to_string(), expected.to_string());
+ };
+
+ ($input:expr, Err) => {
+ syn::parse2::<VisRest>($input.parse().unwrap()).unwrap_err();
+ };
+}
+
+#[test]
+fn test_pub() {
+ assert_vis_parse!("pub", Ok(Visibility::Public(_)));
+}
+
+#[test]
+fn test_crate() {
+ assert_vis_parse!("crate", Ok(Visibility::Crate(_)));
+}
+
+#[test]
+fn test_inherited() {
+ assert_vis_parse!("", Ok(Visibility::Inherited));
+}
+
+#[test]
+fn test_in() {
+ assert_vis_parse!("pub(in foo::bar)", Ok(Visibility::Restricted(_)));
+}
+
+#[test]
+fn test_pub_crate() {
+ assert_vis_parse!("pub(crate)", Ok(Visibility::Restricted(_)));
+}
+
+#[test]
+fn test_pub_self() {
+ assert_vis_parse!("pub(self)", Ok(Visibility::Restricted(_)));
+}
+
+#[test]
+fn test_pub_super() {
+ assert_vis_parse!("pub(super)", Ok(Visibility::Restricted(_)));
+}
+
+#[test]
+fn test_missing_in() {
+ assert_vis_parse!("pub(foo::bar)", Ok(Visibility::Public(_)) + "(foo::bar)");
+}
+
+#[test]
+fn test_missing_in_path() {
+ assert_vis_parse!("pub(in)", Err);
+}
+
+#[test]
+fn test_crate_path() {
+ assert_vis_parse!("pub(crate::A, crate::B)", Ok(Visibility::Public(_)) + "(crate::A, crate::B)");
+}
+
+#[test]
+fn test_junk_after_in() {
+ assert_vis_parse!("pub(in some::path @@garbage)", Err);
+}