diff --git a/Cargo.lock b/Cargo.lock
index 6d40b19892790..a5a7521abde13 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3112,6 +3112,7 @@ dependencies = [
"serialize",
"smallvec",
"syntax",
+ "syntax_expand",
"syntax_pos",
]
@@ -3427,6 +3428,7 @@ dependencies = [
"rustc_target",
"serialize",
"syntax",
+ "syntax_expand",
"syntax_pos",
"tempfile",
]
@@ -3559,6 +3561,7 @@ dependencies = [
"serialize",
"smallvec",
"syntax",
+ "syntax_expand",
"syntax_ext",
"syntax_pos",
"tempfile",
@@ -3630,6 +3633,7 @@ dependencies = [
"smallvec",
"stable_deref_trait",
"syntax",
+ "syntax_expand",
"syntax_pos",
]
@@ -3678,6 +3682,7 @@ dependencies = [
"rustc_index",
"rustc_target",
"syntax",
+ "syntax_expand",
"syntax_pos",
]
@@ -3695,6 +3700,7 @@ dependencies = [
"rustc",
"rustc_metadata",
"syntax",
+ "syntax_expand",
"syntax_pos",
]
@@ -3723,6 +3729,7 @@ dependencies = [
"rustc_metadata",
"smallvec",
"syntax",
+ "syntax_expand",
"syntax_pos",
]
@@ -4336,6 +4343,25 @@ dependencies = [
"syntax_pos",
]
+[[package]]
+name = "syntax_expand"
+version = "0.0.0"
+dependencies = [
+ "bitflags",
+ "lazy_static 1.3.0",
+ "log",
+ "rustc_data_structures",
+ "rustc_errors",
+ "rustc_index",
+ "rustc_lexer",
+ "rustc_target",
+ "scoped-tls",
+ "serialize",
+ "smallvec",
+ "syntax",
+ "syntax_pos",
+]
+
[[package]]
name = "syntax_ext"
version = "0.0.0"
@@ -4347,6 +4373,7 @@ dependencies = [
"rustc_target",
"smallvec",
"syntax",
+ "syntax_expand",
"syntax_pos",
]
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 9b5d9431ae204..567b8ea722491 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -142,6 +142,9 @@ impl<T> Box<T> {
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
let layout = alloc::Layout::new::<mem::MaybeUninit<T>>();
+ if layout.size() == 0 {
+ return Box(NonNull::dangling().into())
+ }
let ptr = unsafe {
Global.alloc(layout)
.unwrap_or_else(|_| alloc::handle_alloc_error(layout))
@@ -182,9 +185,16 @@ impl<T> Box<[T]> {
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
let layout = alloc::Layout::array::<mem::MaybeUninit<T>>(len).unwrap();
- let ptr = unsafe { alloc::alloc(layout) };
- let unique = Unique::new(ptr).unwrap_or_else(|| alloc::handle_alloc_error(layout));
- let slice = unsafe { slice::from_raw_parts_mut(unique.cast().as_ptr(), len) };
+ let ptr = if layout.size() == 0 {
+ NonNull::dangling()
+ } else {
+ unsafe {
+ Global.alloc(layout)
+ .unwrap_or_else(|_| alloc::handle_alloc_error(layout))
+ .cast()
+ }
+ };
+ let slice = unsafe { slice::from_raw_parts_mut(ptr.as_ptr(), len) };
Box(Unique::from(slice))
}
}
diff --git a/src/liballoc/tests/boxed.rs b/src/liballoc/tests/boxed.rs
new file mode 100644
index 0000000000000..53ec6f3f40110
--- /dev/null
+++ b/src/liballoc/tests/boxed.rs
@@ -0,0 +1,19 @@
+use std::ptr::NonNull;
+use std::mem::MaybeUninit;
+
+#[test]
+fn unitialized_zero_size_box() {
+ assert_eq!(
+ &*Box::<()>::new_uninit() as *const _,
+ NonNull::<MaybeUninit<()>>::dangling().as_ptr(),
+ );
+ assert_eq!(
+ Box::<[()]>::new_uninit_slice(4).as_ptr(),
+ NonNull::<MaybeUninit<()>>::dangling().as_ptr(),
+ );
+ assert_eq!(
+ Box::<[String]>::new_uninit_slice(0).as_ptr(),
+ NonNull::<MaybeUninit<String>>::dangling().as_ptr(),
+ );
+}
+
diff --git a/src/liballoc/tests/lib.rs b/src/liballoc/tests/lib.rs
index f2a2c80f2f7ee..676874c8b27df 100644
--- a/src/liballoc/tests/lib.rs
+++ b/src/liballoc/tests/lib.rs
@@ -2,6 +2,7 @@
#![feature(box_syntax)]
#![feature(drain_filter)]
#![feature(exact_size_is_empty)]
+#![feature(new_uninit)]
#![feature(option_flattening)]
#![feature(pattern)]
#![feature(trusted_len)]
@@ -14,6 +15,7 @@ use std::collections::hash_map::DefaultHasher;
mod arc;
mod binary_heap;
+mod boxed;
mod btree;
mod cow_str;
mod fmt;
diff --git a/src/libcore/any.rs b/src/libcore/any.rs
index f75b7a4544384..e2704e807d104 100644
--- a/src/libcore/any.rs
+++ b/src/libcore/any.rs
@@ -445,6 +445,15 @@ impl TypeId {
///
/// The current implementation uses the same infrastructure as compiler
/// diagnostics and debuginfo, but this is not guaranteed.
+///
+/// # Example
+///
+/// ```rust
+/// assert_eq!(
+/// std::any::type_name::<Option<String>>(),
+/// "core::option::Option<alloc::string::String>",
+/// );
+/// ```
#[stable(feature = "type_name", since = "1.38.0")]
#[rustc_const_unstable(feature = "const_type_name")]
pub const fn type_name<T: ?Sized>() -> &'static str {
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 5dfdd1623061e..8413b2e0ac49e 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -108,10 +108,10 @@ pub struct Error;
/// [`io::Write`]: ../../std/io/trait.Write.html
#[stable(feature = "rust1", since = "1.0.0")]
pub trait Write {
- /// Writes a slice of bytes into this writer, returning whether the write
+ /// Writes a string slice into this writer, returning whether the write
/// succeeded.
///
- /// This method can only succeed if the entire byte slice was successfully
+ /// This method can only succeed if the entire string slice was successfully
/// written, and this method will not return until all data has been
/// written or an error occurs.
///
diff --git a/src/librustc/Cargo.toml b/src/librustc/Cargo.toml
index 9b3609eca3e62..cf9f36ca37c90 100644
--- a/src/librustc/Cargo.toml
+++ b/src/librustc/Cargo.toml
@@ -29,6 +29,7 @@ rustc_index = { path = "../librustc_index" }
errors = { path = "../librustc_errors", package = "rustc_errors" }
rustc_serialize = { path = "../libserialize", package = "serialize" }
syntax = { path = "../libsyntax" }
+syntax_expand = { path = "../libsyntax_expand" }
syntax_pos = { path = "../libsyntax_pos" }
backtrace = "0.3.3"
parking_lot = "0.9"
diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs
index f7d31ca06ee56..a071a539e01df 100644
--- a/src/librustc/hir/def.rs
+++ b/src/librustc/hir/def.rs
@@ -6,7 +6,7 @@ use crate::ty;
use crate::util::nodemap::DefIdMap;
use syntax::ast;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax::ast::NodeId;
use syntax_pos::Span;
use rustc_macros::HashStable;
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index e9788a558124a..d5287fd415b7f 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -64,15 +64,15 @@ use syntax::ast;
use syntax::ptr::P as AstP;
use syntax::ast::*;
use syntax::errors;
-use syntax::ext::base::SpecialDerives;
-use syntax::ext::hygiene::ExpnId;
+use syntax_expand::base::SpecialDerives;
use syntax::print::pprust;
-use syntax::tokenstream::{TokenStream, TokenTree};
use syntax::parse::token::{self, Nonterminal, Token};
+use syntax::tokenstream::{TokenStream, TokenTree};
use syntax::sess::ParseSess;
use syntax::source_map::{respan, ExpnData, ExpnKind, DesugaringKind, Spanned};
use syntax::symbol::{kw, sym, Symbol};
use syntax::visit::{self, Visitor};
+use syntax_pos::hygiene::ExpnId;
use syntax_pos::Span;
const HIR_ID_COUNTER_LOCKED: u32 = 0xFFFFFFFF;
diff --git a/src/librustc/hir/lowering/item.rs b/src/librustc/hir/lowering/item.rs
index 548a2fedfff6d..73d2ac5c134d3 100644
--- a/src/librustc/hir/lowering/item.rs
+++ b/src/librustc/hir/lowering/item.rs
@@ -18,7 +18,7 @@ use smallvec::SmallVec;
use syntax::attr;
use syntax::ast::*;
use syntax::visit::{self, Visitor};
-use syntax::ext::base::SpecialDerives;
+use syntax_expand::base::SpecialDerives;
use syntax::source_map::{respan, DesugaringKind, Spanned};
use syntax::symbol::{kw, sym};
use syntax_pos::Span;
diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs
index 1997e2aab35e8..fbef95fec7dc3 100644
--- a/src/librustc/hir/map/def_collector.rs
+++ b/src/librustc/hir/map/def_collector.rs
@@ -2,7 +2,7 @@ use crate::hir::map::definitions::*;
use crate::hir::def_id::DefIndex;
use syntax::ast::*;
-use syntax::ext::hygiene::ExpnId;
+use syntax_expand::hygiene::ExpnId;
use syntax::visit;
use syntax::symbol::{kw, sym};
use syntax::parse::token::{self, Token};
diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs
index 71bf230e37ded..cc099fcc40f6d 100644
--- a/src/librustc/hir/map/definitions.rs
+++ b/src/librustc/hir/map/definitions.rs
@@ -17,7 +17,7 @@ use std::borrow::Borrow;
use std::fmt::Write;
use std::hash::Hash;
use syntax::ast;
-use syntax::ext::hygiene::ExpnId;
+use syntax_expand::hygiene::ExpnId;
use syntax::symbol::{Symbol, sym, InternedString};
use syntax_pos::{Span, DUMMY_SP};
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
index 16c4ab7187de4..f839087ec0271 100644
--- a/src/librustc/hir/map/mod.rs
+++ b/src/librustc/hir/map/mod.rs
@@ -20,7 +20,7 @@ use rustc_data_structures::svh::Svh;
use rustc_index::vec::IndexVec;
use syntax::ast::{self, Name, NodeId};
use syntax::source_map::Spanned;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax_pos::{Span, DUMMY_SP};
pub mod blocks;
diff --git a/src/librustc/ich/hcx.rs b/src/librustc/ich/hcx.rs
index 3e6b271b83497..14d0673ecc03f 100644
--- a/src/librustc/ich/hcx.rs
+++ b/src/librustc/ich/hcx.rs
@@ -13,7 +13,7 @@ use std::cell::RefCell;
use syntax::ast;
use syntax::source_map::SourceMap;
-use syntax::ext::hygiene::SyntaxContext;
+use syntax_expand::hygiene::SyntaxContext;
use syntax::symbol::Symbol;
use syntax::tokenstream::DelimSpan;
use syntax_pos::{Span, DUMMY_SP};
diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs
index 23a2f115e05e2..defc3fb25bc52 100644
--- a/src/librustc/ich/impls_syntax.rs
+++ b/src/librustc/ich/impls_syntax.rs
@@ -59,7 +59,7 @@ impl_stable_hash_for!(enum ::syntax::ast::AsmDialect {
Intel
});
-impl_stable_hash_for!(enum ::syntax::ext::base::MacroKind {
+impl_stable_hash_for!(enum ::syntax_expand::base::MacroKind {
Bang,
Attr,
Derive,
diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs
index b31efc24e52d1..7443cca822a99 100644
--- a/src/librustc/lint/mod.rs
+++ b/src/librustc/lint/mod.rs
@@ -39,7 +39,7 @@ use syntax::ast;
use syntax::source_map::{MultiSpan, ExpnKind, DesugaringKind};
use syntax::early_buffered_lints::BufferedEarlyLintId;
use syntax::edition::Edition;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax::symbol::{Symbol, sym};
use syntax_pos::Span;
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index c59df146629f5..b65bf2230b39d 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -24,7 +24,7 @@ use errors::emitter::HumanReadableErrorType;
use errors::annotate_snippet_emitter_writer::{AnnotateSnippetEmitterWriter};
use syntax::ast::{self, NodeId};
use syntax::edition::Edition;
-use syntax::ext::allocator::AllocatorKind;
+use syntax_expand::allocator::AllocatorKind;
use syntax::feature_gate::{self, AttributeType};
use syntax::json::JsonEmitter;
use syntax::source_map;
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 65aea7b459f83..ab9fb1df6828f 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -45,7 +45,7 @@ use std::{mem, ptr};
use std::ops::Range;
use syntax::ast::{self, Name, Ident, NodeId};
use syntax::attr;
-use syntax::ext::hygiene::ExpnId;
+use syntax_expand::hygiene::ExpnId;
use syntax::symbol::{kw, sym, Symbol, InternedString};
use syntax_pos::Span;
diff --git a/src/librustc_codegen_llvm/allocator.rs b/src/librustc_codegen_llvm/allocator.rs
index f31765cea4f12..8c60c030eacdb 100644
--- a/src/librustc_codegen_llvm/allocator.rs
+++ b/src/librustc_codegen_llvm/allocator.rs
@@ -3,7 +3,7 @@ use std::ffi::CString;
use crate::attributes;
use libc::c_uint;
use rustc::ty::TyCtxt;
-use syntax::ext::allocator::{AllocatorKind, AllocatorTy, ALLOCATOR_METHODS};
+use syntax_expand::allocator::{AllocatorKind, AllocatorTy, ALLOCATOR_METHODS};
use crate::ModuleLlvm;
use crate::llvm::{self, False, True};
diff --git a/src/librustc_codegen_llvm/lib.rs b/src/librustc_codegen_llvm/lib.rs
index fde04a68457d0..9b55bef0c514d 100644
--- a/src/librustc_codegen_llvm/lib.rs
+++ b/src/librustc_codegen_llvm/lib.rs
@@ -39,6 +39,7 @@ extern crate rustc_driver as _;
#[macro_use] extern crate log;
extern crate syntax;
+extern crate syntax_expand;
extern crate syntax_pos;
extern crate rustc_errors as errors;
@@ -48,7 +49,7 @@ use rustc_codegen_ssa::back::lto::{SerializedModule, LtoModuleCodegen, ThinModul
use rustc_codegen_ssa::CompiledModule;
use errors::{FatalError, Handler};
use rustc::dep_graph::WorkProduct;
-use syntax::ext::allocator::AllocatorKind;
+use syntax_expand::allocator::AllocatorKind;
use syntax_pos::symbol::InternedString;
pub use llvm_util::target_features;
use std::any::Any;
diff --git a/src/librustc_codegen_ssa/Cargo.toml b/src/librustc_codegen_ssa/Cargo.toml
index c7d09a423d5e3..6992f93d99949 100644
--- a/src/librustc_codegen_ssa/Cargo.toml
+++ b/src/librustc_codegen_ssa/Cargo.toml
@@ -21,6 +21,7 @@ tempfile = "3.1"
rustc_serialize = { path = "../libserialize", package = "serialize" }
syntax = { path = "../libsyntax" }
+syntax_expand = { path = "../libsyntax_expand" }
syntax_pos = { path = "../libsyntax_pos" }
rustc = { path = "../librustc" }
rustc_apfloat = { path = "../librustc_apfloat" }
diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs
index 9078f77f1f7a2..d866a10f06935 100644
--- a/src/librustc_codegen_ssa/back/symbol_export.rs
+++ b/src/librustc_codegen_ssa/back/symbol_export.rs
@@ -14,7 +14,7 @@ use rustc::ty::query::Providers;
use rustc::ty::subst::SubstsRef;
use rustc::util::nodemap::{FxHashMap, DefIdMap};
use rustc_index::vec::IndexVec;
-use syntax::ext::allocator::ALLOCATOR_METHODS;
+use syntax_expand::allocator::ALLOCATOR_METHODS;
pub type ExportedSymbols = FxHashMap<
CrateNum,
diff --git a/src/librustc_codegen_ssa/back/write.rs b/src/librustc_codegen_ssa/back/write.rs
index 5339134a2a849..856c280cac0fb 100644
--- a/src/librustc_codegen_ssa/back/write.rs
+++ b/src/librustc_codegen_ssa/back/write.rs
@@ -27,7 +27,7 @@ use rustc_errors::{Handler, Level, FatalError, DiagnosticId, SourceMapperDyn};
use rustc_errors::emitter::{Emitter};
use rustc_target::spec::MergeFunctions;
use syntax::attr;
-use syntax::ext::hygiene::ExpnId;
+use syntax_expand::hygiene::ExpnId;
use syntax_pos::symbol::{Symbol, sym};
use jobserver::{Client, Acquired};
diff --git a/src/librustc_codegen_ssa/traits/backend.rs b/src/librustc_codegen_ssa/traits/backend.rs
index a7faf4eaf1022..7cae3e9ade590 100644
--- a/src/librustc_codegen_ssa/traits/backend.rs
+++ b/src/librustc_codegen_ssa/traits/backend.rs
@@ -9,7 +9,7 @@ use rustc::ty::TyCtxt;
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use std::sync::Arc;
use std::sync::mpsc;
-use syntax::ext::allocator::AllocatorKind;
+use syntax_expand::allocator::AllocatorKind;
use syntax_pos::symbol::InternedString;
pub trait BackendTypes {
diff --git a/src/librustc_interface/Cargo.toml b/src/librustc_interface/Cargo.toml
index bed5febb72ede..7a0d931ca732a 100644
--- a/src/librustc_interface/Cargo.toml
+++ b/src/librustc_interface/Cargo.toml
@@ -15,6 +15,7 @@ rayon = { version = "0.3.0", package = "rustc-rayon" }
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
syntax = { path = "../libsyntax" }
syntax_ext = { path = "../libsyntax_ext" }
+syntax_expand = { path = "../libsyntax_expand" }
syntax_pos = { path = "../libsyntax_pos" }
rustc_serialize = { path = "../libserialize", package = "serialize" }
rustc = { path = "../librustc" }
diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
index 396c5610251a3..89de5714695de 100644
--- a/src/librustc_interface/passes.rs
+++ b/src/librustc_interface/passes.rs
@@ -35,7 +35,7 @@ use rustc_traits;
use rustc_typeck as typeck;
use syntax::{self, ast, visit};
use syntax::early_buffered_lints::BufferedEarlyLint;
-use syntax::ext::base::{NamedSyntaxExtension, ExtCtxt};
+use syntax_expand::base::{NamedSyntaxExtension, ExtCtxt};
use syntax::mut_visit::MutVisitor;
use syntax::parse::{self, PResult};
use syntax::util::node_count::NodeCounter;
@@ -397,12 +397,12 @@ fn configure_and_expand_inner<'a>(
// Create the config for macro expansion
let features = sess.features_untracked();
- let cfg = syntax::ext::expand::ExpansionConfig {
+ let cfg = syntax_expand::expand::ExpansionConfig {
features: Some(&features),
recursion_limit: *sess.recursion_limit.get(),
trace_mac: sess.opts.debugging_opts.trace_macros,
should_test: sess.opts.test,
- ..syntax::ext::expand::ExpansionConfig::default(crate_name.to_string())
+ ..syntax_expand::expand::ExpansionConfig::default(crate_name.to_string())
};
let mut ecx = ExtCtxt::new(&sess.parse_sess, cfg, &mut resolver);
@@ -559,7 +559,7 @@ pub fn lower_to_hir(
// Discard hygiene data, which isn't required after lowering to HIR.
if !sess.opts.debugging_opts.keep_hygiene_data {
- syntax::ext::hygiene::clear_syntax_context_map();
+ syntax_expand::hygiene::clear_syntax_context_map();
}
Ok(hir_forest)
diff --git a/src/librustc_metadata/Cargo.toml b/src/librustc_metadata/Cargo.toml
index 032470e1400ab..18192e35f8a20 100644
--- a/src/librustc_metadata/Cargo.toml
+++ b/src/librustc_metadata/Cargo.toml
@@ -22,4 +22,5 @@ rustc_index = { path = "../librustc_index" }
rustc_serialize = { path = "../libserialize", package = "serialize" }
stable_deref_trait = "1.0.0"
syntax = { path = "../libsyntax" }
+syntax_expand = { path = "../libsyntax_expand" }
syntax_pos = { path = "../libsyntax_pos" }
diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs
index 9850121d2ce5d..6a2da5d49887d 100644
--- a/src/librustc_metadata/creader.rs
+++ b/src/librustc_metadata/creader.rs
@@ -26,7 +26,7 @@ use std::{cmp, fs};
use syntax::ast;
use syntax::attr;
-use syntax::ext::allocator::{global_allocator_spans, AllocatorKind};
+use syntax_expand::allocator::{global_allocator_spans, AllocatorKind};
use syntax::symbol::{Symbol, sym};
use syntax::{span_err, span_fatal};
use syntax_pos::{Span, DUMMY_SP};
diff --git a/src/librustc_metadata/cstore.rs b/src/librustc_metadata/cstore.rs
index a5a458e49a38e..9a0b98ffb73a9 100644
--- a/src/librustc_metadata/cstore.rs
+++ b/src/librustc_metadata/cstore.rs
@@ -11,7 +11,7 @@ use rustc_index::vec::IndexVec;
use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::sync::{Lrc, RwLock, Lock, MetadataRef, AtomicCell};
use syntax::ast;
-use syntax::ext::base::SyntaxExtension;
+use syntax_expand::base::SyntaxExtension;
use syntax_pos;
use proc_macro::bridge::client::ProcMacro;
diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs
index 6969d608d76da..37f3726124a23 100644
--- a/src/librustc_metadata/decoder.rs
+++ b/src/librustc_metadata/decoder.rs
@@ -32,11 +32,11 @@ use syntax::attr;
use syntax::ast::{self, Ident};
use syntax::source_map::{self, respan, Spanned};
use syntax::symbol::{Symbol, sym};
-use syntax::ext::base::{MacroKind, SyntaxExtensionKind, SyntaxExtension};
+use syntax_expand::base::{MacroKind, SyntaxExtensionKind, SyntaxExtension};
use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, symbol::{InternedString}};
use log::debug;
use proc_macro::bridge::client::ProcMacro;
-use syntax::ext::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro};
+use syntax_expand::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro};
crate struct DecodeContext<'a, 'tcx> {
opaque: opaque::Decoder<'a>,
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index 03a14f886455a..ac20284233a97 100644
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -31,7 +31,7 @@ use rustc_data_structures::sync::Lrc;
use std::u32;
use syntax::ast;
use syntax::attr;
-use syntax::ext::proc_macro::is_proc_macro_attr;
+use syntax_expand::proc_macro::is_proc_macro_attr;
use syntax::source_map::Spanned;
use syntax::symbol::{kw, sym, Ident, Symbol};
use syntax_pos::{self, FileName, SourceFile, Span};
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index e1c45132103b4..06fdd407951c1 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -35,7 +35,7 @@ pub struct InterpCx<'mir, 'tcx, M: Machine<'mir, 'tcx>> {
pub(crate) param_env: ty::ParamEnv<'tcx>,
/// The virtual memory system.
- pub(crate) memory: Memory<'mir, 'tcx, M>,
+ pub memory: Memory<'mir, 'tcx, M>,
/// The virtual call stack.
pub(crate) stack: Vec<Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>>,
@@ -211,16 +211,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
}
- #[inline(always)]
- pub fn memory(&self) -> &Memory<'mir, 'tcx, M> {
- &self.memory
- }
-
- #[inline(always)]
- pub fn memory_mut(&mut self) -> &mut Memory<'mir, 'tcx, M> {
- &mut self.memory
- }
-
#[inline(always)]
pub fn force_ptr(
&self,
diff --git a/src/librustc_mir/interpret/intern.rs b/src/librustc_mir/interpret/intern.rs
index ec06b6298e112..646d1783c8ec9 100644
--- a/src/librustc_mir/interpret/intern.rs
+++ b/src/librustc_mir/interpret/intern.rs
@@ -73,8 +73,7 @@ fn intern_shallow<'rt, 'mir, 'tcx>(
);
// remove allocation
let tcx = ecx.tcx;
- let memory = ecx.memory_mut();
- let (kind, mut alloc) = match memory.alloc_map.remove(&alloc_id) {
+ let (kind, mut alloc) = match ecx.memory.alloc_map.remove(&alloc_id) {
Some(entry) => entry,
None => {
// Pointer not found in local memory map. It is either a pointer to the global
@@ -332,7 +331,7 @@ pub fn intern_const_alloc_recursive(
let mut todo: Vec<_> = leftover_allocations.iter().cloned().collect();
while let Some(alloc_id) = todo.pop() {
- if let Some((_, mut alloc)) = ecx.memory_mut().alloc_map.remove(&alloc_id) {
+ if let Some((_, mut alloc)) = ecx.memory.alloc_map.remove(&alloc_id) {
// We can't call the `intern_shallow` method here, as its logic is tailored to safe
// references and a `leftover_allocations` set (where we only have a todo-list here).
// So we hand-roll the interning logic here again.
@@ -350,7 +349,7 @@ pub fn intern_const_alloc_recursive(
todo.push(reloc);
}
}
- } else if ecx.memory().dead_alloc_map.contains_key(&alloc_id) {
+ } else if ecx.memory.dead_alloc_map.contains_key(&alloc_id) {
// dangling pointer
throw_unsup!(ValidationFailure("encountered dangling pointer in final constant".into()))
}
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
index 11c7cd0d901d0..7f6baf0bb49c1 100644
--- a/src/librustc_mir/interpret/terminator.rs
+++ b/src/librustc_mir/interpret/terminator.rs
@@ -140,12 +140,12 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
.read_immediate(self.eval_operand(len, None)?)
.expect("can't eval len")
.to_scalar()?
- .to_bits(self.memory().pointer_size())? as u64;
+ .to_bits(self.memory.pointer_size())? as u64;
let index = self
.read_immediate(self.eval_operand(index, None)?)
.expect("can't eval index")
.to_scalar()?
- .to_bits(self.memory().pointer_size())? as u64;
+ .to_bits(self.memory.pointer_size())? as u64;
err_panic!(BoundsCheck { len, index })
}
Overflow(op) => err_panic!(Overflow(*op)),
diff --git a/src/librustc_passes/Cargo.toml b/src/librustc_passes/Cargo.toml
index 9d29a23031443..118deb560d62f 100644
--- a/src/librustc_passes/Cargo.toml
+++ b/src/librustc_passes/Cargo.toml
@@ -13,6 +13,7 @@ log = "0.4"
rustc = { path = "../librustc" }
rustc_data_structures = { path = "../librustc_data_structures" }
syntax = { path = "../libsyntax" }
+syntax_expand = { path = "../libsyntax_expand" }
syntax_pos = { path = "../libsyntax_pos" }
errors = { path = "../librustc_errors", package = "rustc_errors" }
rustc_target = { path = "../librustc_target" }
diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs
index 43c4f720ad41d..74de31263d394 100644
--- a/src/librustc_passes/ast_validation.rs
+++ b/src/librustc_passes/ast_validation.rs
@@ -14,7 +14,7 @@ use rustc::session::Session;
use rustc_data_structures::fx::FxHashMap;
use syntax::ast::*;
use syntax::attr;
-use syntax::ext::proc_macro::is_proc_macro_attr;
+use syntax_expand::proc_macro::is_proc_macro_attr;
use syntax::feature_gate::is_builtin_attr;
use syntax::source_map::Spanned;
use syntax::symbol::{kw, sym};
diff --git a/src/librustc_plugin/Cargo.toml b/src/librustc_plugin/Cargo.toml
index 3f11430dc82cb..e8bf4e7ea8ff6 100644
--- a/src/librustc_plugin/Cargo.toml
+++ b/src/librustc_plugin/Cargo.toml
@@ -14,4 +14,5 @@ doctest = false
rustc = { path = "../librustc" }
rustc_metadata = { path = "../librustc_metadata" }
syntax = { path = "../libsyntax" }
+syntax_expand = { path = "../libsyntax_expand" }
syntax_pos = { path = "../libsyntax_pos" }
diff --git a/src/librustc_plugin/lib.rs b/src/librustc_plugin/lib.rs
index 4e1a47c503e59..38738e20630c9 100644
--- a/src/librustc_plugin/lib.rs
+++ b/src/librustc_plugin/lib.rs
@@ -21,7 +21,7 @@
//! extern crate syntax_pos;
//!
//! use rustc_driver::plugin::Registry;
-//! use syntax::ext::base::{ExtCtxt, MacResult};
+//! use syntax_expand::base::{ExtCtxt, MacResult};
//! use syntax_pos::Span;
//! use syntax::tokenstream::TokenTree;
//!
diff --git a/src/librustc_plugin/registry.rs b/src/librustc_plugin/registry.rs
index bb3c950edae3b..b826dd9119838 100644
--- a/src/librustc_plugin/registry.rs
+++ b/src/librustc_plugin/registry.rs
@@ -4,8 +4,8 @@ use rustc::lint::{EarlyLintPassObject, LateLintPassObject, LintId, Lint};
use rustc::session::Session;
use rustc::util::nodemap::FxHashMap;
-use syntax::ext::base::{SyntaxExtension, SyntaxExtensionKind, NamedSyntaxExtension};
-use syntax::ext::base::MacroExpanderFn;
+use syntax_expand::base::{SyntaxExtension, SyntaxExtensionKind, NamedSyntaxExtension};
+use syntax_expand::base::MacroExpanderFn;
use syntax::symbol::Symbol;
use syntax::ast;
use syntax::feature_gate::AttributeType;
diff --git a/src/librustc_resolve/Cargo.toml b/src/librustc_resolve/Cargo.toml
index 936e72ef2c571..06bf30859898a 100644
--- a/src/librustc_resolve/Cargo.toml
+++ b/src/librustc_resolve/Cargo.toml
@@ -14,6 +14,7 @@ doctest = false
bitflags = "1.0"
log = "0.4"
syntax = { path = "../libsyntax" }
+syntax_expand = { path = "../libsyntax_expand" }
rustc = { path = "../librustc" }
arena = { path = "../libarena" }
errors = { path = "../librustc_errors", package = "rustc_errors" }
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
index 0d5361fe8d84b..eadae52c250a5 100644
--- a/src/librustc_resolve/build_reduced_graph.rs
+++ b/src/librustc_resolve/build_reduced_graph.rs
@@ -32,9 +32,9 @@ use syntax::attr;
use syntax::ast::{self, Block, ForeignItem, ForeignItemKind, Item, ItemKind, NodeId};
use syntax::ast::{MetaItemKind, StmtKind, TraitItem, TraitItemKind};
-use syntax::ext::base::{MacroKind, SyntaxExtension};
-use syntax::ext::expand::AstFragment;
-use syntax::ext::hygiene::ExpnId;
+use syntax_expand::base::{MacroKind, SyntaxExtension};
+use syntax_expand::expand::AstFragment;
+use syntax_expand::hygiene::ExpnId;
use syntax::feature_gate::is_builtin_attr;
use syntax::parse::token::{self, Token};
use syntax::print::pprust;
diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs
index de8758086709f..5647d5b2794af 100644
--- a/src/librustc_resolve/diagnostics.rs
+++ b/src/librustc_resolve/diagnostics.rs
@@ -10,7 +10,7 @@ use rustc::session::Session;
use rustc::ty::{self, DefIdTree};
use rustc::util::nodemap::FxHashSet;
use syntax::ast::{self, Ident, Path};
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax::feature_gate::BUILTIN_ATTRIBUTES;
use syntax::source_map::SourceMap;
use syntax::struct_span_err;
diff --git a/src/librustc_resolve/error_codes.rs b/src/librustc_resolve/error_codes.rs
index 1e65cbada069d..9c5d98f1acba6 100644
--- a/src/librustc_resolve/error_codes.rs
+++ b/src/librustc_resolve/error_codes.rs
@@ -1661,6 +1661,59 @@ match eco {
```
"##,
+E0575: r##"
+Something other than a type or an associated type was given.
+
+Erroneous code example:
+
+```compile_fail,E0575
+enum Rick { Morty }
+
+let _: <u8 as Rick>::Morty; // error!
+
+trait Age {
+ type Empire;
+ fn Mythology() {}
+}
+
+impl Age for u8 {
+ type Empire = u16;
+}
+
+let _: <u8 as Age>::Mythology; // error!
+```
+
+In both cases, we're declaring a variable (called `_`) and we're giving it a
+type. However, `<u8 as Rick>::Morty` and `<u8 as Age>::Mythology` aren't types,
+therefore the compiler throws an error.
+
+`<u8 as Rick>::Morty` is an enum variant, you cannot use a variant as a type,
+you have to use the enum directly:
+
+```
+enum Rick { Morty }
+
+let _: Rick; // ok!
+```
+
+`<u8 as Age>::Mythology` is a trait method, which is definitely not a type.
+However, the `Age` trait provides an associated type `Empire` which can be
+used as a type:
+
+```
+trait Age {
+ type Empire;
+ fn Mythology() {}
+}
+
+impl Age for u8 {
+ type Empire = u16;
+}
+
+let _: <u8 as Age>::Empire; // ok!
+```
+"##,
+
E0603: r##"
A private item was used outside its scope.
@@ -1789,7 +1842,6 @@ struct Foo<X = Box<Self>> {
// E0467, removed
// E0470, removed
E0573,
- E0575,
E0576,
E0577,
E0578,
diff --git a/src/librustc_resolve/late/diagnostics.rs b/src/librustc_resolve/late/diagnostics.rs
index ace9903a835fd..412734eabe05b 100644
--- a/src/librustc_resolve/late/diagnostics.rs
+++ b/src/librustc_resolve/late/diagnostics.rs
@@ -13,7 +13,7 @@ use rustc::hir::PrimTy;
use rustc::session::config::nightly_options;
use rustc::util::nodemap::FxHashSet;
use syntax::ast::{self, Expr, ExprKind, Ident, NodeId, Path, Ty, TyKind};
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax::symbol::kw;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax_pos::Span;
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index e5b0ef89a417f..17d8f0f211a92 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -35,18 +35,16 @@ use rustc::span_bug;
use rustc_metadata::creader::CrateLoader;
use rustc_metadata::cstore::CStore;
-use syntax::ext::hygiene::{ExpnId, Transparency, SyntaxContext};
+use syntax_expand::hygiene::{ExpnId, Transparency, SyntaxContext};
+use syntax_expand::base::{SyntaxExtension, MacroKind, SpecialDerives};
+use syntax::{struct_span_err, unwrap_or};
+use syntax::attr;
use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
-use syntax::ext::base::{SyntaxExtension, MacroKind, SpecialDerives};
+use syntax::ast::{ItemKind, Path, CRATE_NODE_ID, Crate};
use syntax::print::pprust;
use syntax::symbol::{kw, sym};
-
-use syntax::visit::{self, Visitor};
-use syntax::attr;
-use syntax::ast::{CRATE_NODE_ID, Crate};
-use syntax::ast::{ItemKind, Path};
-use syntax::{struct_span_err, unwrap_or};
use syntax::source_map::Spanned;
+use syntax::visit::{self, Visitor};
use syntax_pos::{Span, DUMMY_SP};
use errors::{Applicability, DiagnosticBuilder};
diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs
index 49186088fa06a..c91a0b2ed985f 100644
--- a/src/librustc_resolve/macros.rs
+++ b/src/librustc_resolve/macros.rs
@@ -14,11 +14,11 @@ use rustc::{ty, lint, span_bug};
use syntax::ast::{self, NodeId, Ident};
use syntax::attr::StabilityLevel;
use syntax::edition::Edition;
-use syntax::ext::base::{self, InvocationRes, Indeterminate, SpecialDerives};
-use syntax::ext::base::{MacroKind, SyntaxExtension};
-use syntax::ext::expand::{AstFragment, AstFragmentKind, Invocation, InvocationKind};
-use syntax::ext::hygiene::{self, ExpnId, ExpnData, ExpnKind};
-use syntax::ext::compile_declarative_macro;
+use syntax_expand::base::{self, InvocationRes, Indeterminate, SpecialDerives};
+use syntax_expand::base::{MacroKind, SyntaxExtension};
+use syntax_expand::expand::{AstFragment, AstFragmentKind, Invocation, InvocationKind};
+use syntax_expand::hygiene::{self, ExpnId, ExpnData, ExpnKind};
+use syntax_expand::compile_declarative_macro;
use syntax::feature_gate::{emit_feature_err, is_builtin_attr_name};
use syntax::feature_gate::GateIssue;
use syntax::print::pprust;
diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
index 56fd2da2576fb..424bf31a78505 100644
--- a/src/librustc_resolve/resolve_imports.rs
+++ b/src/librustc_resolve/resolve_imports.rs
@@ -28,7 +28,7 @@ use rustc::util::nodemap::FxHashSet;
use rustc::{bug, span_bug};
use syntax::ast::{Ident, Name, NodeId, CRATE_NODE_ID};
-use syntax::ext::hygiene::ExpnId;
+use syntax_expand::hygiene::ExpnId;
use syntax::symbol::kw;
use syntax::util::lev_distance::find_best_match_for_name;
use syntax::{struct_span_err, unwrap_or};
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 532c5f67bf3ba..63350b2a5d25c 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -3,7 +3,7 @@
use std::iter::once;
use syntax::ast;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax::symbol::sym;
use syntax_pos::Span;
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 212a09ee6e634..ba00631dc6ca2 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -28,7 +28,7 @@ use rustc::ty::layout::VariantIdx;
use rustc::util::nodemap::{FxHashMap, FxHashSet};
use syntax::ast::{self, AttrStyle, Ident};
use syntax::attr;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax::source_map::DUMMY_SP;
use syntax::symbol::{Symbol, kw, sym};
use syntax::symbol::InternedString;
diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs
index 6e453561f6da2..0dc094ae329fb 100644
--- a/src/librustdoc/doctree.rs
+++ b/src/librustdoc/doctree.rs
@@ -4,7 +4,7 @@ pub use self::StructType::*;
use syntax::ast;
use syntax::ast::Name;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax_pos::{self, Span};
use rustc::hir;
diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs
index 5fb9afd6c49a0..e015739b03c40 100644
--- a/src/librustdoc/html/item_type.rs
+++ b/src/librustdoc/html/item_type.rs
@@ -1,7 +1,7 @@
//! Item types.
use std::fmt;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use crate::clean;
/// Item type. Corresponds to `clean::ItemEnum` variants.
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index b726ad1e0d634..72a72e892814a 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -45,11 +45,11 @@ use errors;
use serialize::json::{ToJson, Json, as_json};
use syntax::ast;
use syntax::edition::Edition;
-use syntax::ext::base::MacroKind;
+use syntax::feature_gate::UnstableFeatures;
use syntax::print::pprust;
use syntax::source_map::FileName;
-use syntax::feature_gate::UnstableFeatures;
use syntax::symbol::{Symbol, sym};
+use syntax_expand::base::MacroKind;
use rustc::hir::def_id::DefId;
use rustc::middle::privacy::AccessLevels;
use rustc::middle::stability;
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 6bcb4a817d78e..8cd32a3d1b508 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -34,6 +34,7 @@ extern crate rustc_typeck;
extern crate rustc_lexer;
extern crate serialize;
extern crate syntax;
+extern crate syntax_expand;
extern crate syntax_pos;
extern crate test as testing;
#[macro_use] extern crate log;
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 9186ed514202f..4270b162bafa4 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -7,7 +7,7 @@ use rustc::ty;
use rustc_resolve::ParentScope;
use syntax;
use syntax::ast::{self, Ident};
-use syntax::ext::base::SyntaxExtensionKind;
+use syntax_expand::base::SyntaxExtensionKind;
use syntax::feature_gate::UnstableFeatures;
use syntax::symbol::Symbol;
use syntax_pos::DUMMY_SP;
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index b6a90e1fb988b..70c30687dabca 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -8,7 +8,7 @@ use rustc::middle::privacy::AccessLevel;
use rustc::util::nodemap::{FxHashSet, FxHashMap};
use rustc::ty::TyCtxt;
use syntax::ast;
-use syntax::ext::base::MacroKind;
+use syntax_expand::base::MacroKind;
use syntax::source_map::Spanned;
use syntax::symbol::sym;
use syntax_pos::{self, Span};
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index fc26dcb321148..055686fb0271a 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -1090,13 +1090,14 @@ impl Metadata {
/// Returns the creation time listed in this metadata.
///
- /// The returned value corresponds to the `birthtime` field of `stat` on
+ /// The returned value corresponds to the `btime` field of `statx` on
+ /// Linux not prior to 4.11, the `birthtime` field of `stat` on other
/// Unix platforms and the `ftCreationTime` field on Windows platforms.
///
/// # Errors
///
/// This field may not be available on all platforms, and will return an
- /// `Err` on platforms where it is not available.
+ /// `Err` on platforms or filesystems where it is not available.
///
/// # Examples
///
@@ -1109,7 +1110,7 @@ impl Metadata {
/// if let Ok(time) = metadata.created() {
/// println!("{:?}", time);
/// } else {
- /// println!("Not supported on this platform");
+ /// println!("Not supported on this platform or filesystem");
/// }
/// Ok(())
/// }
@@ -3443,5 +3444,18 @@ mod tests {
check!(a.created());
check!(b.created());
}
+
+ if cfg!(target_os = "linux") {
+ // Not always available
+ match (a.created(), b.created()) {
+ (Ok(t1), Ok(t2)) => assert!(t1 <= t2),
+ (Err(e1), Err(e2)) if e1.kind() == ErrorKind::Other &&
+ e2.kind() == ErrorKind::Other => {}
+ (a, b) => panic!(
+ "creation time must be always supported or not supported: {:?} {:?}",
+ a, b,
+ ),
+ }
+ }
}
}
diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs
index e529b8c4227fa..e28fbca7fa1c2 100644
--- a/src/libstd/sync/once.rs
+++ b/src/libstd/sync/once.rs
@@ -60,10 +60,9 @@ use crate::thread::{self, Thread};
/// A synchronization primitive which can be used to run a one-time global
/// initialization. Useful for one-time initialization for FFI or related
-/// functionality. This type can only be constructed with the [`ONCE_INIT`]
-/// value or the equivalent [`Once::new`] constructor.
+/// functionality. This type can only be constructed with the [`Once::new`]
+/// constructor.
///
-/// [`ONCE_INIT`]: constant.ONCE_INIT.html
/// [`Once::new`]: struct.Once.html#method.new
///
/// # Examples
diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs
index 3b1eb86b84fe1..fee6eecf864a9 100644
--- a/src/libstd/sys/unix/fs.rs
+++ b/src/libstd/sys/unix/fs.rs
@@ -41,11 +41,138 @@ pub use crate::sys_common::fs::remove_dir_all;
pub struct File(FileDesc);
-#[derive(Clone)]
-pub struct FileAttr {
- stat: stat64,
+// FIXME: This should be available on Linux with all `target_arch` and `target_env`.
+// https://github.com/rust-lang/libc/issues/1545
+macro_rules! cfg_has_statx {
+ ({ $($then_tt:tt)* } else { $($else_tt:tt)* }) => {
+ cfg_if::cfg_if! {
+ if #[cfg(all(target_os = "linux", target_env = "gnu", any(
+ target_arch = "x86",
+ target_arch = "arm",
+ // target_arch = "mips",
+ target_arch = "powerpc",
+ target_arch = "x86_64",
+ // target_arch = "aarch64",
+ target_arch = "powerpc64",
+ // target_arch = "mips64",
+ // target_arch = "s390x",
+ target_arch = "sparc64",
+ )))] {
+ $($then_tt)*
+ } else {
+ $($else_tt)*
+ }
+ }
+ };
+ ($($block_inner:tt)*) => {
+ #[cfg(all(target_os = "linux", target_env = "gnu", any(
+ target_arch = "x86",
+ target_arch = "arm",
+ // target_arch = "mips",
+ target_arch = "powerpc",
+ target_arch = "x86_64",
+ // target_arch = "aarch64",
+ target_arch = "powerpc64",
+ // target_arch = "mips64",
+ // target_arch = "s390x",
+ target_arch = "sparc64",
+ )))]
+ {
+ $($block_inner)*
+ }
+ };
}
+cfg_has_statx! {{
+ #[derive(Clone)]
+ pub struct FileAttr {
+ stat: stat64,
+ statx_extra_fields: Option<StatxExtraFields>,
+ }
+
+ #[derive(Clone)]
+ struct StatxExtraFields {
+ // This is needed to check if btime is supported by the filesystem.
+ stx_mask: u32,
+ stx_btime: libc::statx_timestamp,
+ }
+
+ // We prefer `statx` on Linux if available, which contains file creation time.
+ // Default `stat64` contains no creation time.
+ unsafe fn try_statx(
+ fd: c_int,
+ path: *const libc::c_char,
+ flags: i32,
+ mask: u32,
+ ) -> Option<io::Result<FileAttr>> {
+ use crate::sync::atomic::{AtomicBool, Ordering};
+
+ // Linux kernel prior to 4.11 or glibc prior to glibc 2.28 don't support `statx`
+ // We store the availability in a global to avoid unnecessary syscalls
+ static HAS_STATX: AtomicBool = AtomicBool::new(true);
+ syscall! {
+ fn statx(
+ fd: c_int,
+ pathname: *const libc::c_char,
+ flags: c_int,
+ mask: libc::c_uint,
+ statxbuf: *mut libc::statx
+ ) -> c_int
+ }
+
+ if !HAS_STATX.load(Ordering::Relaxed) {
+ return None;
+ }
+
+ let mut buf: libc::statx = mem::zeroed();
+ let ret = cvt(statx(fd, path, flags, mask, &mut buf));
+ match ret {
+ Err(err) => match err.raw_os_error() {
+ Some(libc::ENOSYS) => {
+ HAS_STATX.store(false, Ordering::Relaxed);
+ return None;
+ }
+ _ => return Some(Err(err)),
+ }
+ Ok(_) => {
+ // We cannot fill `stat64` exhaustively because of private padding fields.
+ let mut stat: stat64 = mem::zeroed();
+ // `c_ulong` on gnu-mips, `dev_t` otherwise
+ stat.st_dev = libc::makedev(buf.stx_dev_major, buf.stx_dev_minor) as _;
+ stat.st_ino = buf.stx_ino as libc::ino64_t;
+ stat.st_nlink = buf.stx_nlink as libc::nlink_t;
+ stat.st_mode = buf.stx_mode as libc::mode_t;
+ stat.st_uid = buf.stx_uid as libc::uid_t;
+ stat.st_gid = buf.stx_gid as libc::gid_t;
+ stat.st_rdev = libc::makedev(buf.stx_rdev_major, buf.stx_rdev_minor) as _;
+ stat.st_size = buf.stx_size as off64_t;
+ stat.st_blksize = buf.stx_blksize as libc::blksize_t;
+ stat.st_blocks = buf.stx_blocks as libc::blkcnt64_t;
+ stat.st_atime = buf.stx_atime.tv_sec as libc::time_t;
+ // `i64` on gnu-x86_64-x32, `c_ulong` otherwise.
+ stat.st_atime_nsec = buf.stx_atime.tv_nsec as _;
+ stat.st_mtime = buf.stx_mtime.tv_sec as libc::time_t;
+ stat.st_mtime_nsec = buf.stx_mtime.tv_nsec as _;
+ stat.st_ctime = buf.stx_ctime.tv_sec as libc::time_t;
+ stat.st_ctime_nsec = buf.stx_ctime.tv_nsec as _;
+
+ let extra = StatxExtraFields {
+ stx_mask: buf.stx_mask,
+ stx_btime: buf.stx_btime,
+ };
+
+ Some(Ok(FileAttr { stat, statx_extra_fields: Some(extra) }))
+ }
+ }
+ }
+
+} else {
+ #[derive(Clone)]
+ pub struct FileAttr {
+ stat: stat64,
+ }
+}}
+
// all DirEntry's will have a reference to this struct
struct InnerReadDir {
dirp: Dir,
@@ -97,6 +224,20 @@ pub struct FileType { mode: mode_t }
#[derive(Debug)]
pub struct DirBuilder { mode: mode_t }
+cfg_has_statx! {{
+ impl FileAttr {
+ fn from_stat64(stat: stat64) -> Self {
+ Self { stat, statx_extra_fields: None }
+ }
+ }
+} else {
+ impl FileAttr {
+ fn from_stat64(stat: stat64) -> Self {
+ Self { stat }
+ }
+ }
+}}
+
impl FileAttr {
pub fn size(&self) -> u64 { self.stat.st_size as u64 }
pub fn perm(&self) -> FilePermissions {
@@ -164,6 +305,22 @@ impl FileAttr {
target_os = "macos",
target_os = "ios")))]
pub fn created(&self) -> io::Result<SystemTime> {
+ cfg_has_statx! {
+ if let Some(ext) = &self.statx_extra_fields {
+ return if (ext.stx_mask & libc::STATX_BTIME) != 0 {
+ Ok(SystemTime::from(libc::timespec {
+ tv_sec: ext.stx_btime.tv_sec as libc::time_t,
+ tv_nsec: ext.stx_btime.tv_nsec as libc::c_long,
+ }))
+ } else {
+ Err(io::Error::new(
+ io::ErrorKind::Other,
+ "creation time is not available for the filesystem",
+ ))
+ };
+ }
+ }
+
Err(io::Error::new(io::ErrorKind::Other,
"creation time is not available on this platform \
currently"))
@@ -306,12 +463,25 @@ impl DirEntry {
#[cfg(any(target_os = "linux", target_os = "emscripten", target_os = "android"))]
pub fn metadata(&self) -> io::Result<FileAttr> {
- let fd = cvt(unsafe {dirfd(self.dir.inner.dirp.0)})?;
+ let fd = cvt(unsafe { dirfd(self.dir.inner.dirp.0) })?;
+ let name = self.entry.d_name.as_ptr();
+
+ cfg_has_statx! {
+ if let Some(ret) = unsafe { try_statx(
+ fd,
+ name,
+ libc::AT_SYMLINK_NOFOLLOW | libc::AT_STATX_SYNC_AS_STAT,
+ libc::STATX_ALL,
+ ) } {
+ return ret;
+ }
+ }
+
let mut stat: stat64 = unsafe { mem::zeroed() };
cvt(unsafe {
- fstatat64(fd, self.entry.d_name.as_ptr(), &mut stat, libc::AT_SYMLINK_NOFOLLOW)
+ fstatat64(fd, name, &mut stat, libc::AT_SYMLINK_NOFOLLOW)
})?;
- Ok(FileAttr { stat })
+ Ok(FileAttr::from_stat64(stat))
}
#[cfg(not(any(target_os = "linux", target_os = "emscripten", target_os = "android")))]
@@ -517,11 +687,24 @@ impl File {
}
pub fn file_attr(&self) -> io::Result<FileAttr> {
+ let fd = self.0.raw();
+
+ cfg_has_statx! {
+ if let Some(ret) = unsafe { try_statx(
+ fd,
+ b"\0" as *const _ as *const libc::c_char,
+ libc::AT_EMPTY_PATH | libc::AT_STATX_SYNC_AS_STAT,
+ libc::STATX_ALL,
+ ) } {
+ return ret;
+ }
+ }
+
let mut stat: stat64 = unsafe { mem::zeroed() };
cvt(unsafe {
- fstat64(self.0.raw(), &mut stat)
+ fstat64(fd, &mut stat)
})?;
- Ok(FileAttr { stat })
+ Ok(FileAttr::from_stat64(stat))
}
pub fn fsync(&self) -> io::Result<()> {
@@ -798,20 +981,44 @@ pub fn link(src: &Path, dst: &Path) -> io::Result<()> {
pub fn stat(p: &Path) -> io::Result<FileAttr> {
let p = cstr(p)?;
+
+ cfg_has_statx! {
+ if let Some(ret) = unsafe { try_statx(
+ libc::AT_FDCWD,
+ p.as_ptr(),
+ libc::AT_STATX_SYNC_AS_STAT,
+ libc::STATX_ALL,
+ ) } {
+ return ret;
+ }
+ }
+
let mut stat: stat64 = unsafe { mem::zeroed() };
cvt(unsafe {
stat64(p.as_ptr(), &mut stat)
})?;
- Ok(FileAttr { stat })
+ Ok(FileAttr::from_stat64(stat))
}
pub fn lstat(p: &Path) -> io::Result<FileAttr> {
let p = cstr(p)?;
+
+ cfg_has_statx! {
+ if let Some(ret) = unsafe { try_statx(
+ libc::AT_FDCWD,
+ p.as_ptr(),
+ libc::AT_SYMLINK_NOFOLLOW | libc::AT_STATX_SYNC_AS_STAT,
+ libc::STATX_ALL,
+ ) } {
+ return ret;
+ }
+ }
+
let mut stat: stat64 = unsafe { mem::zeroed() };
cvt(unsafe {
lstat64(p.as_ptr(), &mut stat)
})?;
- Ok(FileAttr { stat })
+ Ok(FileAttr::from_stat64(stat))
}
pub fn canonicalize(p: &Path) -> io::Result<PathBuf> {
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 79d91125ec4c4..0408d7d1bc2aa 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -2,30 +2,29 @@
pub use GenericArgs::*;
pub use UnsafeSource::*;
-pub use crate::symbol::{Ident, Symbol as Name};
pub use crate::util::parser::ExprPrecedence;
-use crate::ext::hygiene::ExpnId;
use crate::parse::token::{self, DelimToken};
use crate::ptr::P;
use crate::source_map::{dummy_spanned, respan, Spanned};
-use crate::symbol::{kw, sym, Symbol};
use crate::tokenstream::TokenStream;
-use crate::ThinVec;
+
+use rustc_target::spec::abi::Abi;
+pub use rustc_target::abi::FloatTy;
+
+use syntax_pos::{Span, DUMMY_SP, ExpnId};
+use syntax_pos::symbol::{kw, sym, Symbol};
+pub use syntax_pos::symbol::{Ident, Symbol as Name};
use rustc_index::vec::Idx;
#[cfg(target_arch = "x86_64")]
use rustc_data_structures::static_assert_size;
-use rustc_target::spec::abi::Abi;
-use syntax_pos::{Span, DUMMY_SP};
-
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::sync::Lrc;
+use rustc_data_structures::thin_vec::ThinVec;
use rustc_serialize::{self, Decoder, Encoder};
use std::fmt;
-pub use rustc_target::abi::FloatTy;
-
#[cfg(test)]
mod tests;
diff --git a/src/libsyntax/attr/builtin.rs b/src/libsyntax/attr/builtin.rs
index 1fe698c2572ca..28b61c5aa77cc 100644
--- a/src/libsyntax/attr/builtin.rs
+++ b/src/libsyntax/attr/builtin.rs
@@ -2,7 +2,6 @@
use crate::ast::{self, Attribute, MetaItem, NestedMetaItem};
use crate::early_buffered_lints::BufferedEarlyLintId;
-use crate::ext::base::ExtCtxt;
use crate::feature_gate::{Features, GatedCfg};
use crate::print::pprust;
use crate::sess::ParseSess;
@@ -32,6 +31,10 @@ pub struct AttributeTemplate {
}
impl AttributeTemplate {
+ pub fn only_word() -> Self {
+ Self { word: true, list: None, name_value_str: None }
+ }
+
/// Checks that the given meta-item is compatible with this template.
fn compatible(&self, meta_item_kind: &ast::MetaItemKind) -> bool {
match meta_item_kind {
@@ -937,14 +940,7 @@ pub fn find_transparency(
(transparency.map_or(fallback, |t| t.0), error)
}
-pub fn check_builtin_macro_attribute(ecx: &ExtCtxt<'_>, meta_item: &MetaItem, name: Symbol) {
- // All the built-in macro attributes are "words" at the moment.
- let template = AttributeTemplate { word: true, list: None, name_value_str: None };
- let attr = ecx.attribute(meta_item.clone());
- check_builtin_attribute(ecx.parse_sess, &attr, name, template);
-}
-
-crate fn check_builtin_attribute(
+pub fn check_builtin_attribute(
sess: &ParseSess, attr: &ast::Attribute, name: Symbol, template: AttributeTemplate
) {
// Some special attributes like `cfg` must be checked
diff --git a/src/libsyntax/attr/mod.rs b/src/libsyntax/attr/mod.rs
index d291e502c2553..402c2cad72f99 100644
--- a/src/libsyntax/attr/mod.rs
+++ b/src/libsyntax/attr/mod.rs
@@ -280,7 +280,7 @@ impl Attribute {
self.item.meta(self.span)
}
- pub fn parse<'a, T, F>(&self, sess: &'a ParseSess, mut f: F) -> PResult<'a, T>
+ crate fn parse<'a, T, F>(&self, sess: &'a ParseSess, mut f: F) -> PResult<'a, T>
where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
{
let mut parser = Parser::new(
@@ -298,24 +298,11 @@ impl Attribute {
Ok(result)
}
- pub fn parse_list<'a, T, F>(&self, sess: &'a ParseSess, mut f: F) -> PResult<'a, Vec<T>>
- where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>,
- {
+ pub fn parse_derive_paths<'a>(&self, sess: &'a ParseSess) -> PResult<'a, Vec<Path>> {
if self.tokens.is_empty() {
return Ok(Vec::new());
}
- self.parse(sess, |parser| {
- parser.expect(&token::OpenDelim(token::Paren))?;
- let mut list = Vec::new();
- while !parser.eat(&token::CloseDelim(token::Paren)) {
- list.push(f(parser)?);
- if !parser.eat(&token::Comma) {
- parser.expect(&token::CloseDelim(token::Paren))?;
- break
- }
- }
- Ok(list)
- })
+ self.parse(sess, |p| p.parse_derive_paths())
}
pub fn parse_meta<'a>(&self, sess: &'a ParseSess) -> PResult<'a, MetaItem> {
diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs
index 2099d018b7b3d..54dc95291d67f 100644
--- a/src/libsyntax/config.rs
+++ b/src/libsyntax/config.rs
@@ -10,7 +10,6 @@ use crate::attr;
use crate::ast;
use crate::edition::Edition;
use crate::mut_visit::*;
-use crate::parse::token;
use crate::ptr::P;
use crate::sess::ParseSess;
use crate::symbol::sym;
@@ -57,6 +56,7 @@ pub fn features(mut krate: ast::Crate, sess: &ParseSess, edition: Edition,
(krate, features)
}
+#[macro_export]
macro_rules! configure {
($this:ident, $node:ident) => {
match $this.configure($node) {
@@ -112,25 +112,7 @@ impl<'a> StripUnconfigured<'a> {
return vec![];
}
- let (cfg_predicate, expanded_attrs) = match attr.parse(self.sess, |parser| {
- parser.expect(&token::OpenDelim(token::Paren))?;
-
- let cfg_predicate = parser.parse_meta_item()?;
- parser.expect(&token::Comma)?;
-
- // Presumably, the majority of the time there will only be one attr.
- let mut expanded_attrs = Vec::with_capacity(1);
-
- while !parser.check(&token::CloseDelim(token::Paren)) {
- let lo = parser.token.span.lo();
- let item = parser.parse_attr_item()?;
- expanded_attrs.push((item, parser.prev_span.with_lo(lo)));
- parser.expect_one_of(&[token::Comma], &[token::CloseDelim(token::Paren)])?;
- }
-
- parser.expect(&token::CloseDelim(token::Paren))?;
- Ok((cfg_predicate, expanded_attrs))
- }) {
+ let (cfg_predicate, expanded_attrs) = match attr.parse(self.sess, |p| p.parse_cfg_attr()) {
Ok(result) => result,
Err(mut e) => {
e.emit();
diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index c07b6050afe31..172511f0f099b 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -56,7 +56,7 @@ macro_rules! gate_feature {
};
}
-crate fn check_attribute(attr: &ast::Attribute, parse_sess: &ParseSess, features: &Features) {
+pub fn check_attribute(attr: &ast::Attribute, parse_sess: &ParseSess, features: &Features) {
PostExpansionVisitor { parse_sess, features }.visit_attribute(attr)
}
diff --git a/src/libsyntax/feature_gate/mod.rs b/src/libsyntax/feature_gate/mod.rs
index ca13ab3620508..ba970618c0e13 100644
--- a/src/libsyntax/feature_gate/mod.rs
+++ b/src/libsyntax/feature_gate/mod.rs
@@ -58,8 +58,7 @@ pub use builtin_attrs::{
deprecated_attributes, is_builtin_attr, is_builtin_attr_name,
};
pub use check::{
- check_crate, get_features, feature_err, emit_feature_err,
+ check_crate, check_attribute, get_features, feature_err, emit_feature_err,
Stability, GateIssue, UnstableFeatures,
EXPLAIN_STMT_ATTR_SYNTAX, EXPLAIN_UNSIZED_TUPLE_COERCION,
};
-crate use check::check_attribute;
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
index fa75f5624f8f8..a68b7fdf931a4 100644
--- a/src/libsyntax/lib.rs
+++ b/src/libsyntax/lib.rs
@@ -13,17 +13,12 @@
#![feature(crate_visibility_modifier)]
#![feature(label_break_value)]
#![feature(nll)]
-#![feature(proc_macro_diagnostic)]
-#![feature(proc_macro_internals)]
-#![feature(proc_macro_span)]
#![feature(try_trait)]
#![feature(slice_patterns)]
#![feature(unicode_internals)]
#![recursion_limit="256"]
-extern crate proc_macro;
-
pub use errors;
use rustc_data_structures::sync::Lock;
use rustc_index::bit_set::GrowableBitSet;
@@ -34,26 +29,7 @@ use syntax_pos::edition::Edition;
#[cfg(test)]
mod tests;
-const MACRO_ARGUMENTS: Option<&'static str> = Some("macro arguments");
-
-// A variant of 'try!' that panics on an Err. This is used as a crutch on the
-// way towards a non-panic!-prone parser. It should be used for fatal parsing
-// errors; eventually we plan to convert all code using panictry to just use
-// normal try.
-#[macro_export]
-macro_rules! panictry {
- ($e:expr) => ({
- use std::result::Result::{Ok, Err};
- use errors::FatalError;
- match $e {
- Ok(e) => e,
- Err(mut e) => {
- e.emit();
- FatalError.raise()
- }
- }
- })
-}
+pub const MACRO_ARGUMENTS: Option<&'static str> = Some("macro arguments");
// A variant of 'panictry!' that works on a Vec<Diagnostic> instead of a single DiagnosticBuilder.
macro_rules! panictry_buffer {
@@ -157,19 +133,4 @@ pub mod print {
mod helpers;
}
-pub mod ext {
- mod placeholders;
- mod proc_macro_server;
-
- pub use syntax_pos::hygiene;
- pub use mbe::macro_rules::compile_declarative_macro;
- pub mod allocator;
- pub mod base;
- pub mod build;
- pub mod expand;
- pub mod proc_macro;
-
- crate mod mbe;
-}
-
pub mod early_buffered_lints;
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index cb90caab77a88..e6b794a6a990e 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -2,7 +2,7 @@
use crate::ast;
use crate::parse::parser::{Parser, emit_unclosed_delims};
-use crate::parse::token::{Nonterminal, TokenKind};
+use crate::parse::token::Nonterminal;
use crate::tokenstream::{self, TokenStream, TokenTree};
use crate::print::pprust;
use crate::sess::ParseSess;
@@ -24,12 +24,10 @@ mod tests;
#[macro_use]
pub mod parser;
-pub mod attr;
pub mod lexer;
pub mod token;
crate mod classify;
-crate mod diagnostics;
crate mod literal;
crate mod unescape_error_reporting;
@@ -273,30 +271,6 @@ pub fn stream_to_parser_with_base_dir<'a>(
Parser::new(sess, stream, Some(base_dir), true, false, None)
}
-/// A sequence separator.
-pub struct SeqSep {
- /// The separator token.
- pub sep: Option<TokenKind>,
- /// `true` if a trailing separator is allowed.
- pub trailing_sep_allowed: bool,
-}
-
-impl SeqSep {
- pub fn trailing_allowed(t: TokenKind) -> SeqSep {
- SeqSep {
- sep: Some(t),
- trailing_sep_allowed: true,
- }
- }
-
- pub fn none() -> SeqSep {
- SeqSep {
- sep: None,
- trailing_sep_allowed: false,
- }
- }
-}
-
// NOTE(Centril): The following probably shouldn't be here but it acknowledges the
// fact that architecturally, we are using parsing (read on below to understand why).
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 86383761484db..9cb410a8ae318 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1,21 +1,21 @@
+pub mod attr;
mod expr;
mod pat;
mod item;
-pub use item::AliasKind;
mod module;
-pub use module::{ModulePath, ModulePathSuccess};
mod ty;
mod path;
pub use path::PathStyle;
mod stmt;
mod generics;
-use super::diagnostics::Error;
+mod diagnostics;
+use diagnostics::Error;
use crate::ast::{
self, DUMMY_NODE_ID, AttrStyle, Attribute, CrateSugar, Ident,
IsAsync, MacDelimiter, Mutability, StrStyle, Visibility, VisibilityKind, Unsafety,
};
-use crate::parse::{PResult, Directory, DirectoryOwnership, SeqSep};
+use crate::parse::{PResult, Directory, DirectoryOwnership};
use crate::parse::lexer::UnmatchedBrace;
use crate::parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration};
use crate::parse::token::{self, Token, TokenKind, DelimToken};
@@ -44,14 +44,14 @@ bitflags::bitflags! {
}
#[derive(Clone, Copy, PartialEq, Debug)]
-crate enum SemiColonMode {
+enum SemiColonMode {
Break,
Ignore,
Comma,
}
#[derive(Clone, Copy, PartialEq, Debug)]
-crate enum BlockMode {
+enum BlockMode {
Break,
Ignore,
}
@@ -124,33 +124,33 @@ pub struct Parser<'a> {
prev_token_kind: PrevTokenKind,
restrictions: Restrictions,
/// Used to determine the path to externally loaded source files.
- crate directory: Directory<'a>,
+ pub(super) directory: Directory<'a>,
/// `true` to parse sub-modules in other files.
- pub recurse_into_file_modules: bool,
+ pub(super) recurse_into_file_modules: bool,
/// Name of the root module this parser originated from. If `None`, then the
/// name is not known. This does not change while the parser is descending
/// into modules, and sub-parsers have new values for this name.
pub root_module_name: Option<String>,
- crate expected_tokens: Vec<TokenType>,
+ expected_tokens: Vec<TokenType>,
token_cursor: TokenCursor,
desugar_doc_comments: bool,
/// `true` we should configure out of line modules as we parse.
- pub cfg_mods: bool,
+ cfg_mods: bool,
/// This field is used to keep track of how many left angle brackets we have seen. This is
/// required in order to detect extra leading left angle brackets (`<` characters) and error
/// appropriately.
///
/// See the comments in the `parse_path_segment` function for more details.
- crate unmatched_angle_bracket_count: u32,
- crate max_angle_bracket_count: u32,
+ unmatched_angle_bracket_count: u32,
+ max_angle_bracket_count: u32,
/// A list of all unclosed delimiters found by the lexer. If an entry is used for error recovery
/// it gets removed from here. Every entry left at the end gets emitted as an independent
/// error.
- crate unclosed_delims: Vec<UnmatchedBrace>,
- crate last_unexpected_token_span: Option<Span>,
- crate last_type_ascription: Option<(Span, bool /* likely path typo */)>,
+ pub(super) unclosed_delims: Vec<UnmatchedBrace>,
+ last_unexpected_token_span: Option<Span>,
+ pub last_type_ascription: Option<(Span, bool /* likely path typo */)>,
/// If present, this `Parser` is not parsing Rust code but rather a macro call.
- crate subparser_name: Option<&'static str>,
+ subparser_name: Option<&'static str>,
}
impl<'a> Drop for Parser<'a> {
@@ -194,7 +194,7 @@ struct TokenCursorFrame {
/// You can find some more example usage of this in the `collect_tokens` method
/// on the parser.
#[derive(Clone)]
-crate enum LastToken {
+enum LastToken {
Collecting(Vec<TreeAndJoint>),
Was(Option<TreeAndJoint>),
}
@@ -297,7 +297,7 @@ impl TokenCursor {
}
#[derive(Clone, PartialEq)]
-crate enum TokenType {
+enum TokenType {
Token(TokenKind),
Keyword(Symbol),
Operator,
@@ -309,7 +309,7 @@ crate enum TokenType {
}
impl TokenType {
- crate fn to_string(&self) -> String {
+ fn to_string(&self) -> String {
match *self {
TokenType::Token(ref t) => format!("`{}`", pprust::token_kind_to_string(t)),
TokenType::Keyword(kw) => format!("`{}`", kw),
@@ -324,11 +324,35 @@ impl TokenType {
}
#[derive(Copy, Clone, Debug)]
-crate enum TokenExpectType {
+enum TokenExpectType {
Expect,
NoExpect,
}
+/// A sequence separator.
+struct SeqSep {
+ /// The separator token.
+ sep: Option<TokenKind>,
+ /// `true` if a trailing separator is allowed.
+ trailing_sep_allowed: bool,
+}
+
+impl SeqSep {
+ fn trailing_allowed(t: TokenKind) -> SeqSep {
+ SeqSep {
+ sep: Some(t),
+ trailing_sep_allowed: true,
+ }
+ }
+
+ fn none() -> SeqSep {
+ SeqSep {
+ sep: None,
+ trailing_sep_allowed: false,
+ }
+ }
+}
+
impl<'a> Parser<'a> {
pub fn new(
sess: &'a ParseSess,
@@ -405,7 +429,7 @@ impl<'a> Parser<'a> {
pprust::token_to_string(&self.token)
}
- crate fn token_descr(&self) -> Option<&'static str> {
+ fn token_descr(&self) -> Option<&'static str> {
Some(match &self.token.kind {
_ if self.token.is_special_ident() => "reserved identifier",
_ if self.token.is_used_keyword() => "keyword",
@@ -415,7 +439,7 @@ impl<'a> Parser<'a> {
})
}
- crate fn this_token_descr(&self) -> String {
+ pub(super) fn this_token_descr(&self) -> String {
if let Some(prefix) = self.token_descr() {
format!("{} `{}`", prefix, self.this_token_to_string())
} else {
@@ -465,7 +489,7 @@ impl<'a> Parser<'a> {
}
}
- pub fn parse_ident(&mut self) -> PResult<'a, ast::Ident> {
+ fn parse_ident(&mut self) -> PResult<'a, ast::Ident> {
self.parse_ident_common(true)
}
@@ -498,7 +522,7 @@ impl<'a> Parser<'a> {
///
/// This method will automatically add `tok` to `expected_tokens` if `tok` is not
/// encountered.
- crate fn check(&mut self, tok: &TokenKind) -> bool {
+ fn check(&mut self, tok: &TokenKind) -> bool {
let is_present = self.token == *tok;
if !is_present { self.expected_tokens.push(TokenType::Token(tok.clone())); }
is_present
@@ -520,7 +544,7 @@ impl<'a> Parser<'a> {
/// If the next token is the given keyword, eats it and returns `true`.
/// Otherwise, returns `false`. An expectation is also added for diagnostics purposes.
- pub fn eat_keyword(&mut self, kw: Symbol) -> bool {
+ fn eat_keyword(&mut self, kw: Symbol) -> bool {
if self.check_keyword(kw) {
self.bump();
true
@@ -558,7 +582,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn check_ident(&mut self) -> bool {
+ fn check_ident(&mut self) -> bool {
self.check_or_expected(self.token.is_ident(), TokenType::Ident)
}
@@ -723,7 +747,7 @@ impl<'a> Parser<'a> {
/// Parses a sequence, including the closing delimiter. The function
/// `f` must consume tokens until reaching the next separator or
/// closing bracket.
- pub fn parse_seq_to_end<T>(
+ fn parse_seq_to_end<T>(
&mut self,
ket: &TokenKind,
sep: SeqSep,
@@ -739,7 +763,7 @@ impl<'a> Parser<'a> {
/// Parses a sequence, not including the closing delimiter. The function
/// `f` must consume tokens until reaching the next separator or
/// closing bracket.
- pub fn parse_seq_to_before_end<T>(
+ fn parse_seq_to_before_end<T>(
&mut self,
ket: &TokenKind,
sep: SeqSep,
@@ -757,7 +781,7 @@ impl<'a> Parser<'a> {
})
}
- crate fn parse_seq_to_before_tokens<T>(
+ fn parse_seq_to_before_tokens<T>(
&mut self,
kets: &[&TokenKind],
sep: SeqSep,
@@ -1003,7 +1027,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn process_potential_macro_variable(&mut self) {
+ pub fn process_potential_macro_variable(&mut self) {
self.token = match self.token.kind {
token::Dollar if self.token.span.from_expansion() &&
self.look_ahead(1, |t| t.is_ident()) => {
@@ -1037,7 +1061,7 @@ impl<'a> Parser<'a> {
}
/// Parses a single token tree from the input.
- crate fn parse_token_tree(&mut self) -> TokenTree {
+ pub fn parse_token_tree(&mut self) -> TokenTree {
match self.token.kind {
token::OpenDelim(..) => {
let frame = mem::replace(&mut self.token_cursor.frame,
@@ -1323,7 +1347,7 @@ impl<'a> Parser<'a> {
*t == token::BinOp(token::Star))
}
- pub fn parse_optional_str(&mut self) -> Option<(Symbol, ast::StrStyle, Option<ast::Name>)> {
+ fn parse_optional_str(&mut self) -> Option<(Symbol, ast::StrStyle, Option<ast::Name>)> {
let ret = match self.token.kind {
token::Literal(token::Lit { kind: token::Str, symbol, suffix }) =>
(symbol, ast::StrStyle::Cooked, suffix),
diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/parser/attr.rs
similarity index 91%
rename from src/libsyntax/parse/attr.rs
rename to src/libsyntax/parse/parser/attr.rs
index 0963efcfc8ac0..6f7d1ead4c17c 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/parser/attr.rs
@@ -1,8 +1,7 @@
+use super::{SeqSep, PResult, Parser, TokenType, PathStyle};
use crate::attr;
use crate::ast;
-use crate::parse::{SeqSep, PResult};
use crate::parse::token::{self, Nonterminal, DelimToken};
-use crate::parse::parser::{Parser, TokenType, PathStyle};
use crate::tokenstream::{TokenStream, TokenTree};
use crate::source_map::Span;
@@ -20,7 +19,7 @@ const DEFAULT_UNEXPECTED_INNER_ATTR_ERR_MSG: &str = "an inner attribute is not \
impl<'a> Parser<'a> {
/// Parses attributes that appear before an item.
- crate fn parse_outer_attributes(&mut self) -> PResult<'a, Vec<ast::Attribute>> {
+ pub(super) fn parse_outer_attributes(&mut self) -> PResult<'a, Vec<ast::Attribute>> {
let mut attrs: Vec<ast::Attribute> = Vec::new();
let mut just_parsed_doc_comment = false;
loop {
@@ -84,9 +83,10 @@ impl<'a> Parser<'a> {
/// The same as `parse_attribute`, except it takes in an `InnerAttributeParsePolicy`
/// that prescribes how to handle inner attributes.
- fn parse_attribute_with_inner_parse_policy(&mut self,
- inner_parse_policy: InnerAttributeParsePolicy<'_>)
- -> PResult<'a, ast::Attribute> {
+ fn parse_attribute_with_inner_parse_policy(
+ &mut self,
+ inner_parse_policy: InnerAttributeParsePolicy<'_>
+ ) -> PResult<'a, ast::Attribute> {
debug!("parse_attribute_with_inner_parse_policy: inner_parse_policy={:?} self.token={:?}",
inner_parse_policy,
self.token);
@@ -260,6 +260,27 @@ impl<'a> Parser<'a> {
Ok(lit)
}
+ /// Parses `cfg_attr(pred, attr_item_list)` where `attr_item_list` is comma-delimited.
+ crate fn parse_cfg_attr(&mut self) -> PResult<'a, (ast::MetaItem, Vec<(ast::AttrItem, Span)>)> {
+ self.expect(&token::OpenDelim(token::Paren))?;
+
+ let cfg_predicate = self.parse_meta_item()?;
+ self.expect(&token::Comma)?;
+
+ // Presumably, the majority of the time there will only be one attr.
+ let mut expanded_attrs = Vec::with_capacity(1);
+
+ while !self.check(&token::CloseDelim(token::Paren)) {
+ let lo = self.token.span.lo();
+ let item = self.parse_attr_item()?;
+ expanded_attrs.push((item, self.prev_span.with_lo(lo)));
+ self.expect_one_of(&[token::Comma], &[token::CloseDelim(token::Paren)])?;
+ }
+
+ self.expect(&token::CloseDelim(token::Paren))?;
+ Ok((cfg_predicate, expanded_attrs))
+ }
+
/// Matches the following grammar (per RFC 1559).
///
/// meta_item : PATH ( '=' UNSUFFIXED_LIT | '(' meta_item_inner? ')' )? ;
diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/parser/diagnostics.rs
similarity index 95%
rename from src/libsyntax/parse/diagnostics.rs
rename to src/libsyntax/parse/parser/diagnostics.rs
index 943838d9dda76..06982c789db8b 100644
--- a/src/libsyntax/parse/diagnostics.rs
+++ b/src/libsyntax/parse/parser/diagnostics.rs
@@ -1,9 +1,11 @@
+use super::{
+ BlockMode, PathStyle, SemiColonMode, TokenType, TokenExpectType,
+ SeqSep, PResult, Parser
+};
use crate::ast::{
self, Param, BinOpKind, BindingMode, BlockCheckMode, Expr, ExprKind, Ident, Item, ItemKind,
Mutability, Pat, PatKind, PathSegment, QSelf, Ty, TyKind,
};
-use crate::parse::{SeqSep, PResult, Parser};
-use crate::parse::parser::{BlockMode, PathStyle, SemiColonMode, TokenType, TokenExpectType};
use crate::parse::token::{self, TokenKind};
use crate::print::pprust;
use crate::ptr::P;
@@ -17,8 +19,9 @@ use log::{debug, trace};
use std::mem;
const TURBOFISH: &'static str = "use `::<...>` instead of `<...>` to specify type arguments";
+
/// Creates a placeholder argument.
-crate fn dummy_arg(ident: Ident) -> Param {
+pub(super) fn dummy_arg(ident: Ident) -> Param {
let pat = P(Pat {
id: ast::DUMMY_NODE_ID,
kind: PatKind::Ident(BindingMode::ByValue(Mutability::Immutable), ident, None),
@@ -121,7 +124,7 @@ impl Error {
}
}
-pub trait RecoverQPath: Sized + 'static {
+pub(super) 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;
@@ -173,39 +176,43 @@ impl<'a> Parser<'a> {
self.span_fatal(self.token.span, m)
}
- pub fn span_fatal<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> DiagnosticBuilder<'a> {
+ crate fn span_fatal<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> DiagnosticBuilder<'a> {
self.sess.span_diagnostic.struct_span_fatal(sp, m)
}
- pub fn span_fatal_err<S: Into<MultiSpan>>(&self, sp: S, err: Error) -> DiagnosticBuilder<'a> {
+ pub(super) fn span_fatal_err<S: Into<MultiSpan>>(
+ &self,
+ sp: S,
+ err: Error,
+ ) -> DiagnosticBuilder<'a> {
err.span_err(sp, self.diagnostic())
}
- pub fn bug(&self, m: &str) -> ! {
+ pub(super) fn bug(&self, m: &str) -> ! {
self.sess.span_diagnostic.span_bug(self.token.span, m)
}
- pub fn span_err<S: Into<MultiSpan>>(&self, sp: S, m: &str) {
+ pub(super) fn span_err<S: Into<MultiSpan>>(&self, sp: S, m: &str) {
self.sess.span_diagnostic.span_err(sp, m)
}
- crate fn struct_span_err<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> DiagnosticBuilder<'a> {
+ pub 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) -> ! {
+ pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> ! {
self.sess.span_diagnostic.span_bug(sp, m)
}
- crate fn diagnostic(&self) -> &'a errors::Handler {
+ pub(super) fn diagnostic(&self) -> &'a errors::Handler {
&self.sess.span_diagnostic
}
- crate fn span_to_snippet(&self, span: Span) -> Result<String, SpanSnippetError> {
+ pub(super) fn span_to_snippet(&self, span: Span) -> Result<String, SpanSnippetError> {
self.sess.source_map().span_to_snippet(span)
}
- crate fn expected_ident_found(&self) -> DiagnosticBuilder<'a> {
+ pub(super) fn expected_ident_found(&self) -> DiagnosticBuilder<'a> {
let mut err = self.struct_span_err(
self.token.span,
&format!("expected identifier, found {}", self.this_token_descr()),
@@ -236,7 +243,7 @@ impl<'a> Parser<'a> {
err
}
- pub fn expected_one_of_not_found(
+ pub(super) fn expected_one_of_not_found(
&mut self,
edible: &[TokenKind],
inedible: &[TokenKind],
@@ -423,7 +430,7 @@ impl<'a> Parser<'a> {
/// Eats and discards tokens until one of `kets` is encountered. Respects token trees,
/// passes through any errors encountered. Used for error recovery.
- crate fn eat_to_tokens(&mut self, kets: &[&TokenKind]) {
+ pub(super) fn eat_to_tokens(&mut self, kets: &[&TokenKind]) {
if let Err(ref mut err) = self.parse_seq_to_before_tokens(
kets,
SeqSep::none(),
@@ -441,7 +448,7 @@ impl<'a> Parser<'a> {
/// let _ = vec![1, 2, 3].into_iter().collect::<Vec<usize>>>>();
/// ^^ help: remove extra angle brackets
/// ```
- crate fn check_trailing_angle_brackets(&mut self, segment: &PathSegment, end: TokenKind) {
+ pub(super) fn check_trailing_angle_brackets(&mut self, segment: &PathSegment, end: TokenKind) {
// This function is intended to be invoked after parsing a path segment where there are two
// cases:
//
@@ -560,7 +567,7 @@ impl<'a> Parser<'a> {
/// inner_op r2
/// / \
/// l1 r1
- crate fn check_no_chained_comparison(
+ pub(super) fn check_no_chained_comparison(
&mut self,
lhs: &Expr,
outer_op: &AssocOp,
@@ -695,7 +702,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn maybe_report_ambiguous_plus(
+ pub(super) fn maybe_report_ambiguous_plus(
&mut self,
allow_plus: bool,
impl_dyn_multi: bool,
@@ -768,7 +775,7 @@ impl<'a> Parser<'a> {
/// Tries to recover from associated item paths like `[T]::AssocItem` / `(T, U)::AssocItem`.
/// Attempts to convert the base expression/pattern/type into a type, parses the `::AssocItem`
/// tail, and combines them into a `<Ty>::AssocItem` expression/pattern/type.
- crate fn maybe_recover_from_bad_qpath<T: RecoverQPath>(
+ pub(super) fn maybe_recover_from_bad_qpath<T: RecoverQPath>(
&mut self,
base: P<T>,
allow_recovery: bool,
@@ -784,7 +791,7 @@ impl<'a> Parser<'a> {
/// Given an already parsed `Ty`, parses the `::AssocItem` tail and
/// combines them into a `<Ty>::AssocItem` expression/pattern/type.
- crate fn maybe_recover_from_bad_qpath_stage_2<T: RecoverQPath>(
+ pub(super) fn maybe_recover_from_bad_qpath_stage_2<T: RecoverQPath>(
&mut self,
ty_span: Span,
ty: P<Ty>,
@@ -823,7 +830,7 @@ impl<'a> Parser<'a> {
)))
}
- crate fn maybe_consume_incorrect_semicolon(&mut self, items: &[P<Item>]) -> bool {
+ pub(super) 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(
@@ -859,7 +866,7 @@ impl<'a> Parser<'a> {
/// Creates a `DiagnosticBuilder` for an unexpected token `t` and tries to recover if it is a
/// closing delimiter.
- pub fn unexpected_try_recover(
+ pub(super) fn unexpected_try_recover(
&mut self,
t: &TokenKind,
) -> PResult<'a, bool /* recovered */> {
@@ -909,7 +916,7 @@ impl<'a> Parser<'a> {
Err(err)
}
- crate fn parse_semi_or_incorrect_foreign_fn_body(
+ pub(super) fn parse_semi_or_incorrect_foreign_fn_body(
&mut self,
ident: &Ident,
extern_sp: Span,
@@ -947,7 +954,7 @@ impl<'a> Parser<'a> {
/// Consumes alternative await syntaxes like `await!(<expr>)`, `await <expr>`,
/// `await? <expr>`, `await(<expr>)`, and `await { <expr> }`.
- crate fn parse_incorrect_await_syntax(
+ pub(super) fn parse_incorrect_await_syntax(
&mut self,
lo: Span,
await_sp: Span,
@@ -999,7 +1006,7 @@ impl<'a> Parser<'a> {
}
/// If encountering `future.await()`, consumes and emits an error.
- crate fn recover_from_await_method_call(&mut self) {
+ pub(super) fn recover_from_await_method_call(&mut self) {
if self.token == token::OpenDelim(token::Paren) &&
self.look_ahead(1, |t| t == &token::CloseDelim(token::Paren))
{
@@ -1022,7 +1029,7 @@ impl<'a> Parser<'a> {
/// and suggest writing `for $pat in $expr` instead.
///
/// This should be called before parsing the `$block`.
- crate fn recover_parens_around_for_head(
+ pub(super) fn recover_parens_around_for_head(
&mut self,
pat: P<Pat>,
expr: &Expr,
@@ -1060,7 +1067,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn could_ascription_be_path(&self, node: &ast::ExprKind) -> bool {
+ pub(super) fn could_ascription_be_path(&self, node: &ast::ExprKind) -> bool {
self.token.is_ident() &&
if let ast::ExprKind::Path(..) = node { true } else { false } &&
!self.token.is_reserved_ident() && // v `foo:bar(baz)`
@@ -1074,7 +1081,7 @@ impl<'a> Parser<'a> {
self.look_ahead(2, |t| t == &token::Lt)) // `foo:bar::<baz>`
}
- crate fn recover_seq_parse_error(
+ pub(super) fn recover_seq_parse_error(
&mut self,
delim: token::DelimToken,
lo: Span,
@@ -1091,7 +1098,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn recover_closing_delimiter(
+ pub(super) fn recover_closing_delimiter(
&mut self,
tokens: &[TokenKind],
mut err: DiagnosticBuilder<'a>,
@@ -1142,7 +1149,7 @@ impl<'a> Parser<'a> {
}
/// Recovers from `pub` keyword in places where it seems _reasonable_ but isn't valid.
- crate fn eat_bad_pub(&mut self) {
+ pub(super) fn eat_bad_pub(&mut self) {
if self.token.is_keyword(kw::Pub) {
match self.parse_visibility(false) {
Ok(vis) => {
@@ -1160,7 +1167,7 @@ impl<'a> Parser<'a> {
/// statement. This is something of a best-effort heuristic.
///
/// We terminate when we find an unmatched `}` (without consuming it).
- crate fn recover_stmt(&mut self) {
+ pub(super) fn recover_stmt(&mut self) {
self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore)
}
@@ -1171,7 +1178,11 @@ impl<'a> Parser<'a> {
///
/// If `break_on_block` is `Break`, then we will stop consuming tokens
/// after finding (and consuming) a brace-delimited block.
- crate fn recover_stmt_(&mut self, break_on_semi: SemiColonMode, break_on_block: BlockMode) {
+ pub(super) fn recover_stmt_(
+ &mut self,
+ break_on_semi: SemiColonMode,
+ break_on_block: BlockMode,
+ ) {
let mut brace_depth = 0;
let mut bracket_depth = 0;
let mut in_block = false;
@@ -1239,7 +1250,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn check_for_for_in_in_typo(&mut self, in_span: Span) {
+ pub(super) fn check_for_for_in_in_typo(&mut self, in_span: Span) {
if self.eat_keyword(kw::In) {
// a common typo: `for _ in in bar {}`
self.struct_span_err(self.prev_span, "expected iterable, found keyword `in`")
@@ -1253,14 +1264,14 @@ impl<'a> Parser<'a> {
}
}
- crate fn expected_semi_or_open_brace<T>(&mut self) -> PResult<'a, T> {
+ pub(super) fn expected_semi_or_open_brace<T>(&mut self) -> PResult<'a, T> {
let token_str = self.this_token_descr();
let mut err = self.fatal(&format!("expected `;` or `{{`, found {}", token_str));
err.span_label(self.token.span, "expected `;` or `{`");
Err(err)
}
- crate fn eat_incorrect_doc_comment_for_param_type(&mut self) {
+ pub(super) fn eat_incorrect_doc_comment_for_param_type(&mut self) {
if let token::DocComment(_) = self.token.kind {
self.struct_span_err(
self.token.span,
@@ -1288,7 +1299,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn parameter_without_type(
+ pub(super) fn parameter_without_type(
&mut self,
err: &mut DiagnosticBuilder<'_>,
pat: P<ast::Pat>,
@@ -1351,7 +1362,7 @@ impl<'a> Parser<'a> {
None
}
- crate fn recover_arg_parse(&mut self) -> PResult<'a, (P<ast::Pat>, P<ast::Ty>)> {
+ pub(super) fn recover_arg_parse(&mut self) -> PResult<'a, (P<ast::Pat>, P<ast::Ty>)> {
let pat = self.parse_pat(Some("argument name"))?;
self.expect(&token::Colon)?;
let ty = self.parse_ty()?;
@@ -1379,7 +1390,7 @@ impl<'a> Parser<'a> {
Ok((pat, ty))
}
- crate fn recover_bad_self_param(
+ pub(super) fn recover_bad_self_param(
&mut self,
mut param: ast::Param,
is_trait_item: bool,
@@ -1397,7 +1408,7 @@ impl<'a> Parser<'a> {
Ok(param)
}
- crate fn consume_block(&mut self, delim: token::DelimToken) {
+ pub(super) fn consume_block(&mut self, delim: token::DelimToken) {
let mut brace_depth = 0;
loop {
if self.eat(&token::OpenDelim(delim)) {
@@ -1417,7 +1428,7 @@ impl<'a> Parser<'a> {
}
}
- crate fn expected_expression_found(&self) -> DiagnosticBuilder<'a> {
+ pub(super) fn expected_expression_found(&self) -> DiagnosticBuilder<'a> {
let (span, msg) = match (&self.token.kind, self.subparser_name) {
(&token::Eof, Some(origin)) => {
let sp = self.sess.source_map().next_point(self.token.span);
@@ -1462,7 +1473,7 @@ impl<'a> Parser<'a> {
/// the parameters are *names* (so we don't emit errors about not being able to find `b` in
/// the local scope), but if we find the same name multiple times, like in `fn foo(i8, i8)`,
/// we deduplicate them to not complain about duplicated parameter names.
- crate fn deduplicate_recovered_params_names(&self, fn_inputs: &mut Vec<Param>) {
+ pub(super) fn deduplicate_recovered_params_names(&self, fn_inputs: &mut Vec<Param>) {
let mut seen_inputs = FxHashSet::default();
for input in fn_inputs.iter_mut() {
let opt_ident = if let (PatKind::Ident(_, ident, _), TyKind::Err) = (
diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs
index dd0fd834fb0c9..273f5a5ffa361 100644
--- a/src/libsyntax/parse/parser/expr.rs
+++ b/src/libsyntax/parse/parser/expr.rs
@@ -1,6 +1,7 @@
use super::{Parser, PResult, Restrictions, PrevTokenKind, TokenType, PathStyle, BlockMode};
use super::{SemiColonMode, SeqSep, TokenExpectType};
use super::pat::{GateOr, PARAM_EXPECTED};
+use super::diagnostics::Error;
use crate::parse::literal::LitError;
@@ -12,7 +13,6 @@ use crate::ast::{
use crate::maybe_recover_from_interpolated_ty_qpath;
use crate::parse::classify;
use crate::parse::token::{self, Token, TokenKind};
-use crate::parse::diagnostics::Error;
use crate::print::pprust;
use crate::ptr::P;
use crate::source_map::{self, Span};
@@ -1074,7 +1074,7 @@ impl<'a> Parser<'a> {
}
/// Matches `lit = true | false | token_lit`.
- crate fn parse_lit(&mut self) -> PResult<'a, Lit> {
+ pub(super) fn parse_lit(&mut self) -> PResult<'a, Lit> {
let mut recovered = None;
if self.token == token::Dot {
// Attempt to recover `.4` as `0.4`.
@@ -1233,7 +1233,7 @@ impl<'a> Parser<'a> {
}
/// Matches `'-' lit | lit` (cf. `ast_validation::AstValidator::check_expr_within_pat`).
- crate fn parse_literal_maybe_minus(&mut self) -> PResult<'a, P<Expr>> {
+ pub fn parse_literal_maybe_minus(&mut self) -> PResult<'a, P<Expr>> {
maybe_whole_expr!(self);
let minus_lo = self.token.span;
@@ -1253,7 +1253,7 @@ impl<'a> Parser<'a> {
}
/// Parses a block or unsafe block.
- crate fn parse_block_expr(
+ pub(super) fn parse_block_expr(
&mut self,
opt_label: Option<Label>,
lo: Span,
@@ -1558,7 +1558,7 @@ impl<'a> Parser<'a> {
return Ok(self.mk_expr(lo.to(hi), ExprKind::Match(discriminant, arms), attrs));
}
- crate fn parse_arm(&mut self) -> PResult<'a, Arm> {
+ pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm> {
let attrs = self.parse_outer_attributes()?;
let lo = self.token.span;
let pat = self.parse_top_pat(GateOr::No)?;
@@ -1666,7 +1666,7 @@ impl<'a> Parser<'a> {
}
/// Parses an `async move? {...}` expression.
- pub fn parse_async_block(&mut self, mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
+ fn parse_async_block(&mut self, mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
let span_lo = self.token.span;
self.expect_keyword(kw::Async)?;
let capture_clause = self.parse_capture_clause();
@@ -1946,4 +1946,8 @@ impl<'a> Parser<'a> {
crate fn mk_expr(&self, span: Span, kind: ExprKind, attrs: ThinVec<Attribute>) -> P<Expr> {
P(Expr { kind, span, attrs, id: DUMMY_NODE_ID })
}
+
+ pub(super) fn mk_expr_err(&self, span: Span) -> P<Expr> {
+ self.mk_expr(span, ExprKind::Err, ThinVec::new())
+ }
}
diff --git a/src/libsyntax/parse/parser/generics.rs b/src/libsyntax/parse/parser/generics.rs
index 2ecd9cca3c64b..bfcb0042a75a3 100644
--- a/src/libsyntax/parse/parser/generics.rs
+++ b/src/libsyntax/parse/parser/generics.rs
@@ -74,7 +74,7 @@ impl<'a> Parser<'a> {
/// Parses a (possibly empty) list of lifetime and type parameters, possibly including
/// a trailing comma and erroneous trailing attributes.
- crate fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParam>> {
+ pub(super) fn parse_generic_params(&mut self) -> PResult<'a, Vec<ast::GenericParam>> {
let mut params = Vec::new();
loop {
let attrs = self.parse_outer_attributes()?;
diff --git a/src/libsyntax/parse/parser/item.rs b/src/libsyntax/parse/parser/item.rs
index 08c624b5539d1..0acfd1450d819 100644
--- a/src/libsyntax/parse/parser/item.rs
+++ b/src/libsyntax/parse/parser/item.rs
@@ -1,4 +1,6 @@
use super::{Parser, PResult, PathStyle, SemiColonMode, BlockMode};
+use super::diagnostics::{Error, dummy_arg};
+
use crate::maybe_whole;
use crate::ptr::P;
use crate::ast::{self, DUMMY_NODE_ID, Ident, Attribute, AttrStyle, AnonConst, Item, ItemKind};
@@ -7,10 +9,8 @@ use crate::ast::{PathSegment, IsAuto, Constness, IsAsync, Unsafety, Defaultness}
use crate::ast::{Visibility, VisibilityKind, Mutability, FnHeader, ForeignItem, ForeignItemKind};
use crate::ast::{Ty, TyKind, Generics, GenericBounds, TraitRef, EnumDef, VariantData, StructField};
use crate::ast::{Mac, MacDelimiter, Block, BindingMode, FnDecl, MethodSig, SelfKind, Param};
-use crate::ext::base::DummyResult;
use crate::parse::token;
use crate::parse::parser::maybe_append;
-use crate::parse::diagnostics::{Error, dummy_arg};
use crate::tokenstream::{TokenTree, TokenStream};
use crate::symbol::{kw, sym};
use crate::source_map::{self, respan, Span};
@@ -23,7 +23,7 @@ use errors::{Applicability, DiagnosticBuilder, DiagnosticId, StashKey};
/// Whether the type alias or associated type is a concrete type or an opaque type.
#[derive(Debug)]
-pub enum AliasKind {
+pub(super) enum AliasKind {
/// Just a new name for the same type.
Weak(P<Ty>),
/// Only trait impls of the type will be usable, not the actual type itself.
@@ -605,7 +605,7 @@ impl<'a> Parser<'a> {
let ty_second = if self.token == token::DotDot {
// We need to report this error after `cfg` expansion for compatibility reasons
self.bump(); // `..`, do not add it to expected tokens
- Some(DummyResult::raw_ty(self.prev_span, true))
+ Some(self.mk_ty(self.prev_span, TyKind::Err))
} else if has_for || self.token.can_begin_type() {
Some(self.parse_ty()?)
} else {
@@ -1116,7 +1116,7 @@ impl<'a> Parser<'a> {
}
/// Parses a foreign item.
- crate fn parse_foreign_item(&mut self, extern_sp: Span) -> PResult<'a, ForeignItem> {
+ pub fn parse_foreign_item(&mut self, extern_sp: Span) -> PResult<'a, ForeignItem> {
maybe_whole!(self, NtForeignItem, |ni| ni);
let attrs = self.parse_outer_attributes()?;
diff --git a/src/libsyntax/parse/parser/module.rs b/src/libsyntax/parse/parser/module.rs
index 2d2fb487d7df2..a0e4d2bbb7ac6 100644
--- a/src/libsyntax/parse/parser/module.rs
+++ b/src/libsyntax/parse/parser/module.rs
@@ -1,24 +1,24 @@
use super::{Parser, PResult};
use super::item::ItemInfo;
+use super::diagnostics::Error;
use crate::attr;
use crate::ast::{self, Ident, Attribute, ItemKind, Mod, Crate};
use crate::parse::{new_sub_parser_from_file, DirectoryOwnership};
use crate::parse::token::{self, TokenKind};
-use crate::parse::diagnostics::{Error};
use crate::source_map::{SourceMap, Span, DUMMY_SP, FileName};
use crate::symbol::sym;
use std::path::{self, Path, PathBuf};
/// Information about the path to a module.
-pub struct ModulePath {
+pub(super) struct ModulePath {
name: String,
path_exists: bool,
pub result: Result<ModulePathSuccess, Error>,
}
-pub struct ModulePathSuccess {
+pub(super) struct ModulePathSuccess {
pub path: PathBuf,
pub directory_ownership: DirectoryOwnership,
warn: bool,
@@ -39,6 +39,8 @@ impl<'a> Parser<'a> {
/// Parses a `mod <foo> { ... }` or `mod <foo>;` item.
pub(super) fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> PResult<'a, ItemInfo> {
let (in_cfg, outer_attrs) = {
+ // FIXME(Centril): This results in a cycle between config and parsing.
+ // Consider using dynamic dispatch via `self.sess` to disentangle the knot.
let mut strip_unconfigured = crate::config::StripUnconfigured {
sess: self.sess,
features: None, // Don't perform gated feature checking.
@@ -198,7 +200,7 @@ impl<'a> Parser<'a> {
}
}
- pub fn submod_path_from_attr(attrs: &[Attribute], dir_path: &Path) -> Option<PathBuf> {
+ pub(super) fn submod_path_from_attr(attrs: &[Attribute], dir_path: &Path) -> Option<PathBuf> {
if let Some(s) = attr::first_attr_value_str_by_name(attrs, sym::path) {
let s = s.as_str();
@@ -215,7 +217,7 @@ impl<'a> Parser<'a> {
}
/// Returns a path to a module.
- pub fn default_submod_path(
+ pub(super) fn default_submod_path(
id: ast::Ident,
relative: Option<ast::Ident>,
dir_path: &Path,
diff --git a/src/libsyntax/parse/parser/pat.rs b/src/libsyntax/parse/parser/pat.rs
index e288346a32927..af795e51792ff 100644
--- a/src/libsyntax/parse/parser/pat.rs
+++ b/src/libsyntax/parse/parser/pat.rs
@@ -22,7 +22,7 @@ const WHILE_PARSING_OR_MSG: &str = "while parsing this or-pattern starting here"
/// Whether or not an or-pattern should be gated when occurring in the current context.
#[derive(PartialEq)]
-pub enum GateOr { Yes, No }
+pub(super) enum GateOr { Yes, No }
/// Whether or not to recover a `,` when parsing or-patterns.
#[derive(PartialEq, Copy, Clone)]
diff --git a/src/libsyntax/parse/parser/path.rs b/src/libsyntax/parse/parser/path.rs
index ca823991a2e5f..639d61a2b5cd4 100644
--- a/src/libsyntax/parse/parser/path.rs
+++ b/src/libsyntax/parse/parser/path.rs
@@ -111,7 +111,7 @@ impl<'a> Parser<'a> {
/// Like `parse_path`, but also supports parsing `Word` meta items into paths for
/// backwards-compatibility. This is used when parsing derive macro paths in `#[derive]`
/// attributes.
- pub fn parse_path_allowing_meta(&mut self, style: PathStyle) -> PResult<'a, Path> {
+ fn parse_path_allowing_meta(&mut self, style: PathStyle) -> PResult<'a, Path> {
let meta_ident = match self.token.kind {
token::Interpolated(ref nt) => match **nt {
token::NtMeta(ref item) => match item.tokens.is_empty() {
@@ -129,7 +129,22 @@ impl<'a> Parser<'a> {
self.parse_path(style)
}
- crate fn parse_path_segments(
+ /// Parse a list of paths inside `#[derive(path_0, ..., path_n)]`.
+ crate fn parse_derive_paths(&mut self) -> PResult<'a, Vec<Path>> {
+ self.expect(&token::OpenDelim(token::Paren))?;
+ let mut list = Vec::new();
+ while !self.eat(&token::CloseDelim(token::Paren)) {
+ let path = self.parse_path_allowing_meta(PathStyle::Mod)?;
+ list.push(path);
+ if !self.eat(&token::Comma) {
+ self.expect(&token::CloseDelim(token::Paren))?;
+ break
+ }
+ }
+ Ok(list)
+ }
+
+ pub(super) fn parse_path_segments(
&mut self,
segments: &mut Vec<PathSegment>,
style: PathStyle,
diff --git a/src/libsyntax/parse/parser/stmt.rs b/src/libsyntax/parse/parser/stmt.rs
index 855b03ddd6f6b..d54d9c4b8e9fa 100644
--- a/src/libsyntax/parse/parser/stmt.rs
+++ b/src/libsyntax/parse/parser/stmt.rs
@@ -2,14 +2,13 @@ use super::{Parser, PResult, Restrictions, PrevTokenKind, SemiColonMode, BlockMo
use super::expr::LhsExpr;
use super::path::PathStyle;
use super::pat::GateOr;
+use super::diagnostics::Error;
use crate::ptr::P;
use crate::{maybe_whole, ThinVec};
use crate::ast::{self, DUMMY_NODE_ID, Stmt, StmtKind, Local, Block, BlockCheckMode, Expr, ExprKind};
use crate::ast::{Attribute, AttrStyle, VisibilityKind, MacStmtStyle, Mac, MacDelimiter};
-use crate::ext::base::DummyResult;
use crate::parse::{classify, DirectoryOwnership};
-use crate::parse::diagnostics::Error;
use crate::parse::token;
use crate::source_map::{respan, Span};
use crate::symbol::{kw, sym};
@@ -373,7 +372,9 @@ impl<'a> Parser<'a> {
}
/// Parses a block. Inner attributes are allowed.
- crate fn parse_inner_attrs_and_block(&mut self) -> PResult<'a, (Vec<Attribute>, P<Block>)> {
+ pub(super) fn parse_inner_attrs_and_block(
+ &mut self
+ ) -> PResult<'a, (Vec<Attribute>, P<Block>)> {
maybe_whole!(self, NtBlock, |x| (Vec::new(), x));
let lo = self.token.span;
@@ -400,7 +401,7 @@ impl<'a> Parser<'a> {
self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
Some(Stmt {
id: DUMMY_NODE_ID,
- kind: StmtKind::Expr(DummyResult::raw_expr(self.token.span, true)),
+ kind: StmtKind::Expr(self.mk_expr_err(self.token.span)),
span: self.token.span,
})
}
@@ -422,7 +423,7 @@ impl<'a> Parser<'a> {
}
/// Parses a statement, including the trailing semicolon.
- crate fn parse_full_stmt(&mut self, macro_legacy_warnings: bool) -> PResult<'a, Option<Stmt>> {
+ pub fn parse_full_stmt(&mut self, macro_legacy_warnings: bool) -> PResult<'a, Option<Stmt>> {
// Skip looking for a trailing semicolon when we have an interpolated statement.
maybe_whole!(self, NtStmt, |x| Some(x));
@@ -443,7 +444,7 @@ impl<'a> Parser<'a> {
self.recover_stmt();
// Don't complain about type errors in body tail after parse error (#57383).
let sp = expr.span.to(self.prev_span);
- stmt.kind = StmtKind::Expr(DummyResult::raw_expr(sp, true));
+ stmt.kind = StmtKind::Expr(self.mk_expr_err(sp));
}
}
}
diff --git a/src/libsyntax/parse/parser/ty.rs b/src/libsyntax/parse/parser/ty.rs
index e696ab0804d69..86c94b680b2c9 100644
--- a/src/libsyntax/parse/parser/ty.rs
+++ b/src/libsyntax/parse/parser/ty.rs
@@ -210,7 +210,7 @@ impl<'a> Parser<'a> {
};
let span = lo.to(self.prev_span);
- let ty = P(Ty { kind, span, id: ast::DUMMY_NODE_ID });
+ let ty = self.mk_ty(span, kind);
// Try to recover from use of `+` with incorrect priority.
self.maybe_report_ambiguous_plus(allow_plus, impl_dyn_multi, &ty);
@@ -296,7 +296,7 @@ impl<'a> Parser<'a> {
})))
}
- crate fn parse_generic_bounds(&mut self,
+ pub(super) fn parse_generic_bounds(&mut self,
colon_span: Option<Span>) -> PResult<'a, GenericBounds> {
self.parse_generic_bounds_common(true, colon_span)
}
@@ -433,13 +433,13 @@ impl<'a> Parser<'a> {
}
}
- crate fn check_lifetime(&mut self) -> bool {
+ pub fn check_lifetime(&mut self) -> bool {
self.expected_tokens.push(TokenType::Lifetime);
self.token.is_lifetime()
}
/// Parses a single lifetime `'a` or panics.
- crate fn expect_lifetime(&mut self) -> Lifetime {
+ pub fn expect_lifetime(&mut self) -> Lifetime {
if let Some(ident) = self.token.lifetime() {
let span = self.token.span;
self.bump();
@@ -448,4 +448,8 @@ impl<'a> Parser<'a> {
self.span_bug(self.token.span, "not a lifetime")
}
}
+
+ pub(super) fn mk_ty(&self, span: Span, kind: TyKind) -> P<Ty> {
+ P(Ty { kind, span, id: ast::DUMMY_NODE_ID })
+ }
}
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index eb74ab2b9192d..e527989fb0ba0 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -285,7 +285,7 @@ impl TokenKind {
}
impl Token {
- crate fn new(kind: TokenKind, span: Span) -> Self {
+ pub fn new(kind: TokenKind, span: Span) -> Self {
Token { kind, span }
}
@@ -295,12 +295,12 @@ impl Token {
}
/// Recovers a `Token` from an `ast::Ident`. This creates a raw identifier if necessary.
- crate fn from_ast_ident(ident: ast::Ident) -> Self {
+ pub fn from_ast_ident(ident: ast::Ident) -> Self {
Token::new(Ident(ident.name, ident.is_raw_guess()), ident.span)
}
/// Return this token by value and leave a dummy token in its place.
- crate fn take(&mut self) -> Self {
+ pub fn take(&mut self) -> Self {
mem::replace(self, Token::dummy())
}
@@ -321,7 +321,7 @@ impl Token {
}
/// Returns `true` if the token can appear at the start of an expression.
- crate fn can_begin_expr(&self) -> bool {
+ pub fn can_begin_expr(&self) -> bool {
match self.kind {
Ident(name, is_raw) =>
ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
@@ -353,7 +353,7 @@ impl Token {
}
/// Returns `true` if the token can appear at the start of a type.
- crate fn can_begin_type(&self) -> bool {
+ pub fn can_begin_type(&self) -> bool {
match self.kind {
Ident(name, is_raw) =>
ident_can_begin_type(name, self.span, is_raw), // type name or keyword
@@ -396,7 +396,7 @@ impl Token {
}
/// Returns `true` if the token is any literal
- crate fn is_lit(&self) -> bool {
+ pub fn is_lit(&self) -> bool {
match self.kind {
Literal(..) => true,
_ => false,
@@ -412,7 +412,7 @@ impl Token {
/// Returns `true` if the token is any literal, a minus (which can prefix a literal,
/// for example a '-42', or one of the boolean idents).
- crate fn can_begin_literal_or_bool(&self) -> bool {
+ pub fn can_begin_literal_or_bool(&self) -> bool {
match self.kind {
Literal(..) | BinOp(Minus) => true,
Ident(name, false) if name.is_bool_lit() => true,
diff --git a/src/libsyntax/tests.rs b/src/libsyntax/tests.rs
index fbcf368ccb7b8..881bdaa84d099 100644
--- a/src/libsyntax/tests.rs
+++ b/src/libsyntax/tests.rs
@@ -1,4 +1,4 @@
-use crate::{ast, panictry};
+use crate::ast;
use crate::parse::{PResult, source_file_to_stream};
use crate::parse::new_parser_from_source_str;
use crate::parse::parser::Parser;
@@ -28,7 +28,7 @@ crate fn with_error_checking_parse<'a, T, F>(s: String, ps: &'a ParseSess, f: F)
F: FnOnce(&mut Parser<'a>) -> PResult<'a, T>,
{
let mut p = string_to_parser(&ps, s);
- let x = panictry!(f(&mut p));
+ let x = f(&mut p).unwrap();
p.sess.span_diagnostic.abort_if_errors();
x
}
diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs
index 0ff1c26bac2b2..db6832d642322 100644
--- a/src/libsyntax/tokenstream.rs
+++ b/src/libsyntax/tokenstream.rs
@@ -156,7 +156,7 @@ use IsJoint::*;
impl TokenStream {
/// Given a `TokenStream` with a `Stream` of only two arguments, return a new `TokenStream`
/// separating the two arguments with a comma for diagnostic suggestions.
- pub(crate) fn add_comma(&self) -> Option<(TokenStream, Span)> {
+ pub fn add_comma(&self) -> Option<(TokenStream, Span)> {
// Used to suggest if a user writes `foo!(a b);`
let mut suggestion = None;
let mut iter = self.0.iter().enumerate().peekable();
diff --git a/src/libsyntax_expand/Cargo.toml b/src/libsyntax_expand/Cargo.toml
new file mode 100644
index 0000000000000..f063753f59943
--- /dev/null
+++ b/src/libsyntax_expand/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+authors = ["The Rust Project Developers"]
+name = "syntax_expand"
+version = "0.0.0"
+edition = "2018"
+build = false
+
+[lib]
+name = "syntax_expand"
+path = "lib.rs"
+doctest = false
+
+[dependencies]
+bitflags = "1.0"
+rustc_serialize = { path = "../libserialize", package = "serialize" }
+log = "0.4"
+scoped-tls = "1.0"
+lazy_static = "1.0.0"
+syntax_pos = { path = "../libsyntax_pos" }
+errors = { path = "../librustc_errors", package = "rustc_errors" }
+rustc_data_structures = { path = "../librustc_data_structures" }
+rustc_index = { path = "../librustc_index" }
+rustc_lexer = { path = "../librustc_lexer" }
+rustc_target = { path = "../librustc_target" }
+smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
+syntax = { path = "../libsyntax" }
diff --git a/src/libsyntax/ext/allocator.rs b/src/libsyntax_expand/allocator.rs
similarity index 96%
rename from src/libsyntax/ext/allocator.rs
rename to src/libsyntax_expand/allocator.rs
index 99aeb5414c5d8..3526be17721a8 100644
--- a/src/libsyntax/ext/allocator.rs
+++ b/src/libsyntax_expand/allocator.rs
@@ -1,5 +1,5 @@
-use crate::{ast, attr, visit};
-use crate::symbol::{sym, Symbol};
+use syntax::{ast, attr, visit};
+use syntax::symbol::{sym, Symbol};
use syntax_pos::Span;
#[derive(Clone, Copy)]
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax_expand/base.rs
similarity index 98%
rename from src/libsyntax/ext/base.rs
rename to src/libsyntax_expand/base.rs
index 01be5642d5c43..593e06f29b93c 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax_expand/base.rs
@@ -1,18 +1,19 @@
-use crate::ast::{self, NodeId, Attribute, Name, PatKind};
-use crate::attr::{self, HasAttrs, Stability, Deprecation};
-use crate::source_map::SourceMap;
-use crate::edition::Edition;
-use crate::ext::expand::{self, AstFragment, Invocation};
-use crate::ext::hygiene::ExpnId;
-use crate::mut_visit::{self, MutVisitor};
-use crate::parse::{self, parser, DirectoryOwnership};
-use crate::parse::token;
-use crate::ptr::P;
-use crate::sess::ParseSess;
-use crate::symbol::{kw, sym, Ident, Symbol};
-use crate::{ThinVec, MACRO_ARGUMENTS};
-use crate::tokenstream::{self, TokenStream};
-use crate::visit::Visitor;
+use crate::expand::{self, AstFragment, Invocation};
+use crate::hygiene::ExpnId;
+
+use syntax::ast::{self, NodeId, Attribute, Name, PatKind};
+use syntax::attr::{self, HasAttrs, Stability, Deprecation};
+use syntax::source_map::SourceMap;
+use syntax::edition::Edition;
+use syntax::mut_visit::{self, MutVisitor};
+use syntax::parse::{self, parser, DirectoryOwnership};
+use syntax::parse::token;
+use syntax::ptr::P;
+use syntax::sess::ParseSess;
+use syntax::symbol::{kw, sym, Ident, Symbol};
+use syntax::{ThinVec, MACRO_ARGUMENTS};
+use syntax::tokenstream::{self, TokenStream};
+use syntax::visit::Visitor;
use errors::{DiagnosticBuilder, DiagnosticId};
use smallvec::{smallvec, SmallVec};
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax_expand/build.rs
similarity index 98%
rename from src/libsyntax/ext/build.rs
rename to src/libsyntax_expand/build.rs
index 8c5289671c98e..105ffe3ee8a9f 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax_expand/build.rs
@@ -1,10 +1,11 @@
-use crate::ast::{self, Ident, Expr, BlockCheckMode, UnOp, PatKind};
-use crate::attr;
-use crate::source_map::{respan, Spanned};
-use crate::ext::base::ExtCtxt;
-use crate::ptr::P;
-use crate::symbol::{kw, sym, Symbol};
-use crate::ThinVec;
+use crate::base::ExtCtxt;
+
+use syntax::ast::{self, Ident, Expr, BlockCheckMode, UnOp, PatKind};
+use syntax::attr;
+use syntax::source_map::{respan, Spanned};
+use syntax::ptr::P;
+use syntax::symbol::{kw, sym, Symbol};
+use syntax::ThinVec;
use syntax_pos::{Pos, Span};
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax_expand/expand.rs
similarity index 91%
rename from src/libsyntax/ext/expand.rs
rename to src/libsyntax_expand/expand.rs
index 2559e87476277..47b4bca314a2d 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax_expand/expand.rs
@@ -1,24 +1,26 @@
-use crate::ast::{self, AttrItem, Block, Ident, LitKind, NodeId, PatKind, Path};
-use crate::ast::{MacStmtStyle, StmtKind, ItemKind};
-use crate::attr::{self, HasAttrs};
-use crate::source_map::respan;
-use crate::config::StripUnconfigured;
-use crate::ext::base::*;
-use crate::ext::proc_macro::{collect_derives, MarkAttrs};
-use crate::ext::hygiene::{ExpnId, SyntaxContext, ExpnData, ExpnKind};
-use crate::ext::mbe::macro_rules::annotate_err_with_kind;
-use crate::ext::placeholders::{placeholder, PlaceholderExpander};
-use crate::feature_gate::{self, Features, GateIssue, is_builtin_attr, emit_feature_err};
-use crate::mut_visit::*;
-use crate::parse::{DirectoryOwnership, PResult};
-use crate::parse::token;
-use crate::parse::parser::Parser;
-use crate::print::pprust;
-use crate::ptr::P;
-use crate::symbol::{sym, Symbol};
-use crate::tokenstream::{TokenStream, TokenTree};
-use crate::visit::Visitor;
-use crate::util::map_in_place::MapInPlace;
+use crate::base::*;
+use crate::proc_macro::{collect_derives, MarkAttrs};
+use crate::hygiene::{ExpnId, SyntaxContext, ExpnData, ExpnKind};
+use crate::mbe::macro_rules::annotate_err_with_kind;
+use crate::placeholders::{placeholder, PlaceholderExpander};
+
+use syntax::ast::{self, AttrItem, Block, Ident, LitKind, NodeId, PatKind, Path};
+use syntax::ast::{MacStmtStyle, StmtKind, ItemKind};
+use syntax::attr::{self, HasAttrs};
+use syntax::source_map::respan;
+use syntax::configure;
+use syntax::config::StripUnconfigured;
+use syntax::feature_gate::{self, Features, GateIssue, is_builtin_attr, emit_feature_err};
+use syntax::mut_visit::*;
+use syntax::parse::{DirectoryOwnership, PResult};
+use syntax::parse::token;
+use syntax::parse::parser::Parser;
+use syntax::print::pprust;
+use syntax::ptr::P;
+use syntax::symbol::{sym, Symbol};
+use syntax::tokenstream::{TokenStream, TokenTree};
+use syntax::visit::Visitor;
+use syntax::util::map_in_place::MapInPlace;
use errors::{Applicability, FatalError};
use smallvec::{smallvec, SmallVec};
@@ -116,8 +118,8 @@ macro_rules! ast_fragments {
}
}
- impl<'a> MacResult for crate::ext::mbe::macro_rules::ParserAnyMacro<'a> {
- $(fn $make_ast(self: Box<crate::ext::mbe::macro_rules::ParserAnyMacro<'a>>)
+ impl<'a> MacResult for crate::mbe::macro_rules::ParserAnyMacro<'a> {
+ $(fn $make_ast(self: Box<crate::mbe::macro_rules::ParserAnyMacro<'a>>)
-> Option<$AstTy> {
Some(self.make(AstFragmentKind::$Kind).$make_ast())
})*
@@ -752,9 +754,9 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
span: Span,
) -> AstFragment {
let mut parser = self.cx.new_parser_from_tts(toks);
- match parser.parse_ast_fragment(kind, false) {
+ match parse_ast_fragment(&mut parser, kind, false) {
Ok(fragment) => {
- parser.ensure_complete_parse(path, kind.name(), span);
+ ensure_complete_parse(&mut parser, path, kind.name(), span);
fragment
}
Err(mut err) => {
@@ -768,100 +770,106 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
}
}
-impl<'a> Parser<'a> {
- pub fn parse_ast_fragment(&mut self, kind: AstFragmentKind, macro_legacy_warnings: bool)
- -> PResult<'a, AstFragment> {
- Ok(match kind {
- AstFragmentKind::Items => {
- let mut items = SmallVec::new();
- while let Some(item) = self.parse_item()? {
- items.push(item);
- }
- AstFragment::Items(items)
+pub fn parse_ast_fragment<'a>(
+ this: &mut Parser<'a>,
+ kind: AstFragmentKind,
+ macro_legacy_warnings: bool,
+) -> PResult<'a, AstFragment> {
+ Ok(match kind {
+ AstFragmentKind::Items => {
+ let mut items = SmallVec::new();
+ while let Some(item) = this.parse_item()? {
+ items.push(item);
}
- AstFragmentKind::TraitItems => {
- let mut items = SmallVec::new();
- while self.token != token::Eof {
- items.push(self.parse_trait_item(&mut false)?);
- }
- AstFragment::TraitItems(items)
+ AstFragment::Items(items)
+ }
+ AstFragmentKind::TraitItems => {
+ let mut items = SmallVec::new();
+ while this.token != token::Eof {
+ items.push(this.parse_trait_item(&mut false)?);
}
- AstFragmentKind::ImplItems => {
- let mut items = SmallVec::new();
- while self.token != token::Eof {
- items.push(self.parse_impl_item(&mut false)?);
- }
- AstFragment::ImplItems(items)
+ AstFragment::TraitItems(items)
+ }
+ AstFragmentKind::ImplItems => {
+ let mut items = SmallVec::new();
+ while this.token != token::Eof {
+ items.push(this.parse_impl_item(&mut false)?);
}
- AstFragmentKind::ForeignItems => {
- let mut items = SmallVec::new();
- while self.token != token::Eof {
- items.push(self.parse_foreign_item(DUMMY_SP)?);
- }
- AstFragment::ForeignItems(items)
+ AstFragment::ImplItems(items)
+ }
+ AstFragmentKind::ForeignItems => {
+ let mut items = SmallVec::new();
+ while this.token != token::Eof {
+ items.push(this.parse_foreign_item(DUMMY_SP)?);
}
- AstFragmentKind::Stmts => {
- let mut stmts = SmallVec::new();
- while self.token != token::Eof &&
- // won't make progress on a `}`
- self.token != token::CloseDelim(token::Brace) {
- if let Some(stmt) = self.parse_full_stmt(macro_legacy_warnings)? {
- stmts.push(stmt);
- }
+ AstFragment::ForeignItems(items)
+ }
+ AstFragmentKind::Stmts => {
+ let mut stmts = SmallVec::new();
+ while this.token != token::Eof &&
+ // won't make progress on a `}`
+ this.token != token::CloseDelim(token::Brace) {
+ if let Some(stmt) = this.parse_full_stmt(macro_legacy_warnings)? {
+ stmts.push(stmt);
}
- AstFragment::Stmts(stmts)
}
- AstFragmentKind::Expr => AstFragment::Expr(self.parse_expr()?),
- AstFragmentKind::OptExpr => {
- if self.token != token::Eof {
- AstFragment::OptExpr(Some(self.parse_expr()?))
- } else {
- AstFragment::OptExpr(None)
- }
- },
- AstFragmentKind::Ty => AstFragment::Ty(self.parse_ty()?),
- AstFragmentKind::Pat => AstFragment::Pat(self.parse_pat(None)?),
- AstFragmentKind::Arms
- | AstFragmentKind::Fields
- | AstFragmentKind::FieldPats
- | AstFragmentKind::GenericParams
- | AstFragmentKind::Params
- | AstFragmentKind::StructFields
- | AstFragmentKind::Variants
- => panic!("unexpected AST fragment kind"),
- })
- }
+ AstFragment::Stmts(stmts)
+ }
+ AstFragmentKind::Expr => AstFragment::Expr(this.parse_expr()?),
+ AstFragmentKind::OptExpr => {
+ if this.token != token::Eof {
+ AstFragment::OptExpr(Some(this.parse_expr()?))
+ } else {
+ AstFragment::OptExpr(None)
+ }
+ },
+ AstFragmentKind::Ty => AstFragment::Ty(this.parse_ty()?),
+ AstFragmentKind::Pat => AstFragment::Pat(this.parse_pat(None)?),
+ AstFragmentKind::Arms
+ | AstFragmentKind::Fields
+ | AstFragmentKind::FieldPats
+ | AstFragmentKind::GenericParams
+ | AstFragmentKind::Params
+ | AstFragmentKind::StructFields
+ | AstFragmentKind::Variants
+ => panic!("unexpected AST fragment kind"),
+ })
+}
- pub fn ensure_complete_parse(&mut self, macro_path: &Path, kind_name: &str, span: Span) {
- if self.token != token::Eof {
- let msg = format!("macro expansion ignores token `{}` and any following",
- self.this_token_to_string());
- // Avoid emitting backtrace info twice.
- let def_site_span = self.token.span.with_ctxt(SyntaxContext::root());
- let mut err = self.diagnostic().struct_span_err(def_site_span, &msg);
- err.span_label(span, "caused by the macro expansion here");
- let msg = format!(
- "the usage of `{}!` is likely invalid in {} context",
- pprust::path_to_string(¯o_path),
- kind_name,
- );
- err.note(&msg);
- let semi_span = self.sess.source_map().next_point(span);
-
- let semi_full_span = semi_span.to(self.sess.source_map().next_point(semi_span));
- match self.sess.source_map().span_to_snippet(semi_full_span) {
- Ok(ref snippet) if &snippet[..] != ";" && kind_name == "expression" => {
- err.span_suggestion(
- semi_span,
- "you might be missing a semicolon here",
- ";".to_owned(),
- Applicability::MaybeIncorrect,
- );
- }
- _ => {}
+pub fn ensure_complete_parse<'a>(
+ this: &mut Parser<'a>,
+ macro_path: &Path,
+ kind_name: &str,
+ span: Span,
+) {
+ if this.token != token::Eof {
+ let msg = format!("macro expansion ignores token `{}` and any following",
+ this.this_token_to_string());
+ // Avoid emitting backtrace info twice.
+ let def_site_span = this.token.span.with_ctxt(SyntaxContext::root());
+ let mut err = this.struct_span_err(def_site_span, &msg);
+ err.span_label(span, "caused by the macro expansion here");
+ let msg = format!(
+ "the usage of `{}!` is likely invalid in {} context",
+ pprust::path_to_string(macro_path),
+ kind_name,
+ );
+ err.note(&msg);
+ let semi_span = this.sess.source_map().next_point(span);
+
+ let semi_full_span = semi_span.to(this.sess.source_map().next_point(semi_span));
+ match this.sess.source_map().span_to_snippet(semi_full_span) {
+ Ok(ref snippet) if &snippet[..] != ";" && kind_name == "expression" => {
+ err.span_suggestion(
+ semi_span,
+ "you might be missing a semicolon here",
+ ";".to_owned(),
+ Applicability::MaybeIncorrect,
+ );
}
- err.emit();
+ _ => {}
}
+ err.emit();
}
}
diff --git a/src/libsyntax_expand/lib.rs b/src/libsyntax_expand/lib.rs
new file mode 100644
index 0000000000000..88e69d7939732
--- /dev/null
+++ b/src/libsyntax_expand/lib.rs
@@ -0,0 +1,38 @@
+#![feature(crate_visibility_modifier)]
+#![feature(proc_macro_diagnostic)]
+#![feature(proc_macro_internals)]
+#![feature(proc_macro_span)]
+
+extern crate proc_macro as pm;
+
+// A variant of 'try!' that panics on an Err. This is used as a crutch on the
+// way towards a non-panic!-prone parser. It should be used for fatal parsing
+// errors; eventually we plan to convert all code using panictry to just use
+// normal try.
+#[macro_export]
+macro_rules! panictry {
+ ($e:expr) => ({
+ use std::result::Result::{Ok, Err};
+ use errors::FatalError;
+ match $e {
+ Ok(e) => e,
+ Err(mut e) => {
+ e.emit();
+ FatalError.raise()
+ }
+ }
+ })
+}
+
+mod placeholders;
+mod proc_macro_server;
+
+pub use syntax_pos::hygiene;
+pub use mbe::macro_rules::compile_declarative_macro;
+pub mod allocator;
+pub mod base;
+pub mod build;
+pub mod expand;
+pub mod proc_macro;
+
+crate mod mbe;
diff --git a/src/libsyntax/ext/mbe.rs b/src/libsyntax_expand/mbe.rs
similarity index 98%
rename from src/libsyntax/ext/mbe.rs
rename to src/libsyntax_expand/mbe.rs
index a87da791c9b4f..453fe94f1de19 100644
--- a/src/libsyntax/ext/mbe.rs
+++ b/src/libsyntax_expand/mbe.rs
@@ -9,9 +9,9 @@ crate mod macro_parser;
crate mod macro_rules;
crate mod quoted;
-use crate::ast;
-use crate::parse::token::{self, Token, TokenKind};
-use crate::tokenstream::{DelimSpan};
+use syntax::ast;
+use syntax::parse::token::{self, Token, TokenKind};
+use syntax::tokenstream::{DelimSpan};
use syntax_pos::{BytePos, Span};
diff --git a/src/libsyntax/ext/mbe/macro_check.rs b/src/libsyntax_expand/mbe/macro_check.rs
similarity index 98%
rename from src/libsyntax/ext/mbe/macro_check.rs
rename to src/libsyntax_expand/mbe/macro_check.rs
index aabaff4e1c30c..50abda8d45e97 100644
--- a/src/libsyntax/ext/mbe/macro_check.rs
+++ b/src/libsyntax_expand/mbe/macro_check.rs
@@ -104,13 +104,13 @@
//! Kleene operators under which a meta-variable is repeating is the concatenation of the stacks
//! stored when entering a macro definition starting from the state in which the meta-variable is
//! bound.
-use crate::ast::NodeId;
-use crate::early_buffered_lints::BufferedEarlyLintId;
-use crate::ext::mbe::{KleeneToken, TokenTree};
-use crate::parse::token::TokenKind;
-use crate::parse::token::{DelimToken, Token};
-use crate::sess::ParseSess;
-use crate::symbol::{kw, sym};
+use crate::mbe::{KleeneToken, TokenTree};
+
+use syntax::ast::NodeId;
+use syntax::early_buffered_lints::BufferedEarlyLintId;
+use syntax::parse::token::{DelimToken, Token, TokenKind};
+use syntax::sess::ParseSess;
+use syntax::symbol::{kw, sym};
use rustc_data_structures::fx::FxHashMap;
use smallvec::SmallVec;
diff --git a/src/libsyntax/ext/mbe/macro_parser.rs b/src/libsyntax_expand/mbe/macro_parser.rs
similarity index 98%
rename from src/libsyntax/ext/mbe/macro_parser.rs
rename to src/libsyntax_expand/mbe/macro_parser.rs
index ff382c316ffac..3efe22626a9fa 100644
--- a/src/libsyntax/ext/mbe/macro_parser.rs
+++ b/src/libsyntax_expand/mbe/macro_parser.rs
@@ -74,15 +74,16 @@ crate use NamedMatch::*;
crate use ParseResult::*;
use TokenTreeOrTokenTreeSlice::*;
-use crate::ast::{Ident, Name};
-use crate::ext::mbe::{self, TokenTree};
-use crate::parse::{Directory, PResult};
-use crate::parse::parser::{Parser, PathStyle};
-use crate::parse::token::{self, DocComment, Nonterminal, Token};
-use crate::print::pprust;
-use crate::sess::ParseSess;
-use crate::symbol::{kw, sym, Symbol};
-use crate::tokenstream::{DelimSpan, TokenStream};
+use crate::mbe::{self, TokenTree};
+
+use syntax::ast::{Ident, Name};
+use syntax::parse::{Directory, PResult};
+use syntax::parse::parser::{Parser, PathStyle};
+use syntax::parse::token::{self, DocComment, Nonterminal, Token};
+use syntax::print::pprust;
+use syntax::sess::ParseSess;
+use syntax::symbol::{kw, sym, Symbol};
+use syntax::tokenstream::{DelimSpan, TokenStream};
use errors::FatalError;
use smallvec::{smallvec, SmallVec};
@@ -651,7 +652,7 @@ pub(super) fn parse(
directory,
recurse_into_modules,
true,
- crate::MACRO_ARGUMENTS,
+ syntax::MACRO_ARGUMENTS,
);
// A queue of possible matcher positions. We initialize it with the matcher position in which
@@ -889,6 +890,9 @@ fn may_begin_with(token: &Token, name: Name) -> bool {
///
/// The parsed non-terminal.
fn parse_nt(p: &mut Parser<'_>, sp: Span, name: Symbol) -> Nonterminal {
+ // FIXME(Centril): Consider moving this to `parser.rs` to make
+ // the visibilities of the methods used below `pub(super)` at most.
+
if name == sym::tt {
return token::NtTT(p.parse_token_tree());
}
diff --git a/src/libsyntax/ext/mbe/macro_rules.rs b/src/libsyntax_expand/mbe/macro_rules.rs
similarity index 96%
rename from src/libsyntax/ext/mbe/macro_rules.rs
rename to src/libsyntax_expand/mbe/macro_rules.rs
index b422329842260..9a4130b2d8d02 100644
--- a/src/libsyntax/ext/mbe/macro_rules.rs
+++ b/src/libsyntax_expand/mbe/macro_rules.rs
@@ -1,24 +1,25 @@
-use crate::ast;
-use crate::attr::{self, TransparencyError};
-use crate::edition::Edition;
-use crate::ext::base::{DummyResult, ExtCtxt, MacResult, TTMacroExpander};
-use crate::ext::base::{SyntaxExtension, SyntaxExtensionKind};
-use crate::ext::expand::{AstFragment, AstFragmentKind};
-use crate::ext::mbe;
-use crate::ext::mbe::macro_check;
-use crate::ext::mbe::macro_parser::parse;
-use crate::ext::mbe::macro_parser::{Error, Failure, Success};
-use crate::ext::mbe::macro_parser::{MatchedNonterminal, MatchedSeq, NamedParseResult};
-use crate::ext::mbe::transcribe::transcribe;
-use crate::feature_gate::Features;
-use crate::parse::parser::Parser;
-use crate::parse::token::TokenKind::*;
-use crate::parse::token::{self, NtTT, Token};
-use crate::parse::Directory;
-use crate::print::pprust;
-use crate::sess::ParseSess;
-use crate::symbol::{kw, sym, Symbol};
-use crate::tokenstream::{DelimSpan, TokenStream, TokenTree};
+use crate::base::{DummyResult, ExtCtxt, MacResult, TTMacroExpander};
+use crate::base::{SyntaxExtension, SyntaxExtensionKind};
+use crate::expand::{AstFragment, AstFragmentKind, ensure_complete_parse, parse_ast_fragment};
+use crate::mbe;
+use crate::mbe::macro_check;
+use crate::mbe::macro_parser::parse;
+use crate::mbe::macro_parser::{Error, Failure, Success};
+use crate::mbe::macro_parser::{MatchedNonterminal, MatchedSeq, NamedParseResult};
+use crate::mbe::transcribe::transcribe;
+
+use syntax::ast;
+use syntax::attr::{self, TransparencyError};
+use syntax::edition::Edition;
+use syntax::feature_gate::Features;
+use syntax::parse::parser::Parser;
+use syntax::parse::token::TokenKind::*;
+use syntax::parse::token::{self, NtTT, Token};
+use syntax::parse::Directory;
+use syntax::print::pprust;
+use syntax::sess::ParseSess;
+use syntax::symbol::{kw, sym, Symbol};
+use syntax::tokenstream::{DelimSpan, TokenStream};
use errors::{DiagnosticBuilder, FatalError};
use log::debug;
@@ -66,7 +67,7 @@ crate fn annotate_err_with_kind(
impl<'a> ParserAnyMacro<'a> {
crate fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) -> AstFragment {
let ParserAnyMacro { site_span, macro_ident, ref mut parser, arm_span } = *self;
- let fragment = panictry!(parser.parse_ast_fragment(kind, true).map_err(|mut e| {
+ let fragment = panictry!(parse_ast_fragment(parser, kind, true).map_err(|mut e| {
if parser.token == token::Eof && e.message().ends_with(", found `<eof>`") {
if !e.span.is_dummy() {
// early end of macro arm (#52866)
@@ -128,7 +129,7 @@ impl<'a> ParserAnyMacro<'a> {
// Make sure we don't have any tokens left to parse so we don't silently drop anything.
let path = ast::Path::from_ident(macro_ident.with_span_pos(site_span));
- parser.ensure_complete_parse(&path, kind.name(), site_span);
+ ensure_complete_parse(parser, &path, kind.name(), site_span);
fragment
}
}
@@ -189,7 +190,7 @@ fn generic_extension<'cx>(
_ => cx.span_bug(sp, "malformed macro lhs"),
};
- match TokenTree::parse(cx, lhs_tt, arg.clone()) {
+ match parse_tt(cx, lhs_tt, arg.clone()) {
Success(named_matches) => {
let rhs = match rhses[i] {
// ignore delimiters
@@ -265,7 +266,7 @@ fn generic_extension<'cx>(
mbe::TokenTree::Delimited(_, ref delim) => &delim.tts[..],
_ => continue,
};
- match TokenTree::parse(cx, lhs_tt, arg.clone()) {
+ match parse_tt(cx, lhs_tt, arg.clone()) {
Success(_) => {
if comma_span.is_dummy() {
err.note("you might be missing a comma");
@@ -1158,7 +1159,7 @@ fn is_legal_fragment_specifier(
fn quoted_tt_to_string(tt: &mbe::TokenTree) -> String {
match *tt {
- mbe::TokenTree::Token(ref token) => crate::print::pprust::token_to_string(&token),
+ mbe::TokenTree::Token(ref token) => pprust::token_to_string(&token),
mbe::TokenTree::MetaVar(_, name) => format!("${}", name),
mbe::TokenTree::MetaVarDecl(_, name, kind) => format!("${}:{}", name, kind),
_ => panic!(
@@ -1168,17 +1169,14 @@ fn quoted_tt_to_string(tt: &mbe::TokenTree) -> String {
}
}
-impl TokenTree {
- /// Use this token tree as a matcher to parse given tts.
- fn parse(cx: &ExtCtxt<'_>, mtch: &[mbe::TokenTree], tts: TokenStream)
- -> NamedParseResult {
- // `None` is because we're not interpolating
- let directory = Directory {
- path: Cow::from(cx.current_expansion.module.directory.as_path()),
- ownership: cx.current_expansion.directory_ownership,
- };
- parse(cx.parse_sess(), tts, mtch, Some(directory), true)
- }
+/// Use this token tree as a matcher to parse given tts.
+fn parse_tt(cx: &ExtCtxt<'_>, mtch: &[mbe::TokenTree], tts: TokenStream) -> NamedParseResult {
+ // `None` is because we're not interpolating
+ let directory = Directory {
+ path: Cow::from(cx.current_expansion.module.directory.as_path()),
+ ownership: cx.current_expansion.directory_ownership,
+ };
+ parse(cx.parse_sess(), tts, mtch, Some(directory), true)
}
/// Generates an appropriate parsing failure message. For EOF, this is "unexpected end...". For
diff --git a/src/libsyntax/ext/mbe/quoted.rs b/src/libsyntax_expand/mbe/quoted.rs
similarity index 97%
rename from src/libsyntax/ext/mbe/quoted.rs
rename to src/libsyntax_expand/mbe/quoted.rs
index 3cec4bc60e7a8..cedd59233adf5 100644
--- a/src/libsyntax/ext/mbe/quoted.rs
+++ b/src/libsyntax_expand/mbe/quoted.rs
@@ -1,11 +1,12 @@
-use crate::ast;
-use crate::ext::mbe::macro_parser;
-use crate::ext::mbe::{TokenTree, KleeneOp, KleeneToken, SequenceRepetition, Delimited};
-use crate::parse::token::{self, Token};
-use crate::print::pprust;
-use crate::sess::ParseSess;
-use crate::symbol::kw;
-use crate::tokenstream;
+use crate::mbe::macro_parser;
+use crate::mbe::{TokenTree, KleeneOp, KleeneToken, SequenceRepetition, Delimited};
+
+use syntax::ast;
+use syntax::parse::token::{self, Token};
+use syntax::print::pprust;
+use syntax::sess::ParseSess;
+use syntax::symbol::kw;
+use syntax::tokenstream;
use syntax_pos::Span;
diff --git a/src/libsyntax/ext/mbe/transcribe.rs b/src/libsyntax_expand/mbe/transcribe.rs
similarity index 98%
rename from src/libsyntax/ext/mbe/transcribe.rs
rename to src/libsyntax_expand/mbe/transcribe.rs
index da930436d817b..94523bbf91b5a 100644
--- a/src/libsyntax/ext/mbe/transcribe.rs
+++ b/src/libsyntax_expand/mbe/transcribe.rs
@@ -1,10 +1,11 @@
-use crate::ast::{Ident, Mac};
-use crate::ext::base::ExtCtxt;
-use crate::ext::mbe;
-use crate::ext::mbe::macro_parser::{MatchedNonterminal, MatchedSeq, NamedMatch};
-use crate::mut_visit::{self, MutVisitor};
-use crate::parse::token::{self, NtTT, Token};
-use crate::tokenstream::{DelimSpan, TokenStream, TokenTree, TreeAndJoint};
+use crate::base::ExtCtxt;
+use crate::mbe;
+use crate::mbe::macro_parser::{MatchedNonterminal, MatchedSeq, NamedMatch};
+
+use syntax::ast::{Ident, Mac};
+use syntax::mut_visit::{self, MutVisitor};
+use syntax::parse::token::{self, NtTT, Token};
+use syntax::tokenstream::{DelimSpan, TokenStream, TokenTree, TreeAndJoint};
use smallvec::{smallvec, SmallVec};
diff --git a/src/libsyntax/ext/placeholders.rs b/src/libsyntax_expand/placeholders.rs
similarity index 97%
rename from src/libsyntax/ext/placeholders.rs
rename to src/libsyntax_expand/placeholders.rs
index 4fae25bbde62c..f2c89e14b53b9 100644
--- a/src/libsyntax/ext/placeholders.rs
+++ b/src/libsyntax_expand/placeholders.rs
@@ -1,11 +1,12 @@
-use crate::ast::{self, NodeId};
-use crate::source_map::{DUMMY_SP, dummy_spanned};
-use crate::ext::base::ExtCtxt;
-use crate::ext::expand::{AstFragment, AstFragmentKind};
-use crate::tokenstream::TokenStream;
-use crate::mut_visit::*;
-use crate::ptr::P;
-use crate::ThinVec;
+use crate::base::ExtCtxt;
+use crate::expand::{AstFragment, AstFragmentKind};
+
+use syntax::ast::{self, NodeId};
+use syntax::source_map::{DUMMY_SP, dummy_spanned};
+use syntax::tokenstream::TokenStream;
+use syntax::mut_visit::*;
+use syntax::ptr::P;
+use syntax::ThinVec;
use smallvec::{smallvec, SmallVec};
diff --git a/src/libsyntax/ext/proc_macro.rs b/src/libsyntax_expand/proc_macro.rs
similarity index 86%
rename from src/libsyntax/ext/proc_macro.rs
rename to src/libsyntax_expand/proc_macro.rs
index e17bbf79fd5e0..07b618c99a556 100644
--- a/src/libsyntax/ext/proc_macro.rs
+++ b/src/libsyntax_expand/proc_macro.rs
@@ -1,23 +1,22 @@
-use crate::ast::{self, ItemKind, Attribute, Mac};
-use crate::attr::{mark_used, mark_known};
-use crate::errors::{Applicability, FatalError};
-use crate::ext::base::{self, *};
-use crate::ext::proc_macro_server;
-use crate::parse::{self, token};
-use crate::parse::parser::PathStyle;
-use crate::symbol::sym;
-use crate::tokenstream::{self, TokenStream};
-use crate::visit::Visitor;
+use crate::base::{self, *};
+use crate::proc_macro_server;
+
+use syntax::ast::{self, ItemKind, Attribute, Mac};
+use syntax::attr::{mark_used, mark_known};
+use syntax::errors::{Applicability, FatalError};
+use syntax::parse::{self, token};
+use syntax::symbol::sym;
+use syntax::tokenstream::{self, TokenStream};
+use syntax::visit::Visitor;
use rustc_data_structures::sync::Lrc;
use syntax_pos::{Span, DUMMY_SP};
-const EXEC_STRATEGY: proc_macro::bridge::server::SameThread =
- proc_macro::bridge::server::SameThread;
+const EXEC_STRATEGY: pm::bridge::server::SameThread = pm::bridge::server::SameThread;
pub struct BangProcMacro {
- pub client: proc_macro::bridge::client::Client<
- fn(proc_macro::TokenStream) -> proc_macro::TokenStream,
+ pub client: pm::bridge::client::Client<
+ fn(pm::TokenStream) -> pm::TokenStream,
>,
}
@@ -45,9 +44,7 @@ impl base::ProcMacro for BangProcMacro {
}
pub struct AttrProcMacro {
- pub client: proc_macro::bridge::client::Client<
- fn(proc_macro::TokenStream, proc_macro::TokenStream) -> proc_macro::TokenStream,
- >,
+ pub client: pm::bridge::client::Client<fn(pm::TokenStream, pm::TokenStream) -> pm::TokenStream>,
}
impl base::AttrProcMacro for AttrProcMacro {
@@ -75,9 +72,7 @@ impl base::AttrProcMacro for AttrProcMacro {
}
pub struct ProcMacroDerive {
- pub client: proc_macro::bridge::client::Client<
- fn(proc_macro::TokenStream) -> proc_macro::TokenStream,
- >,
+ pub client: pm::bridge::client::Client<fn(pm::TokenStream) -> pm::TokenStream>,
}
impl MultiItemModifier for ProcMacroDerive {
@@ -205,8 +200,7 @@ crate fn collect_derives(cx: &mut ExtCtxt<'_>, attrs: &mut Vec<ast::Attribute>)
return false;
}
- match attr.parse_list(cx.parse_sess,
- |parser| parser.parse_path_allowing_meta(PathStyle::Mod)) {
+ match attr.parse_derive_paths(cx.parse_sess) {
Ok(traits) => {
result.extend(traits);
true
diff --git a/src/libsyntax/ext/proc_macro_server.rs b/src/libsyntax_expand/proc_macro_server.rs
similarity index 98%
rename from src/libsyntax/ext/proc_macro_server.rs
rename to src/libsyntax_expand/proc_macro_server.rs
index e0e1a1c468c90..4ce99cfe73b5c 100644
--- a/src/libsyntax/ext/proc_macro_server.rs
+++ b/src/libsyntax_expand/proc_macro_server.rs
@@ -1,18 +1,19 @@
-use crate::ast;
-use crate::ext::base::ExtCtxt;
-use crate::parse::{self, token};
-use crate::parse::lexer::comments;
-use crate::print::pprust;
-use crate::sess::ParseSess;
-use crate::tokenstream::{self, DelimSpan, IsJoint::*, TokenStream, TreeAndJoint};
+use crate::base::ExtCtxt;
+
+use syntax::ast;
+use syntax::parse::{self, token};
+use syntax::parse::lexer::comments;
+use syntax::print::pprust;
+use syntax::sess::ParseSess;
+use syntax::tokenstream::{self, DelimSpan, IsJoint::*, TokenStream, TreeAndJoint};
use errors::Diagnostic;
use rustc_data_structures::sync::Lrc;
use syntax_pos::{BytePos, FileName, MultiSpan, Pos, SourceFile, Span};
use syntax_pos::symbol::{kw, sym, Symbol};
-use proc_macro::{Delimiter, Level, LineColumn, Spacing};
-use proc_macro::bridge::{server, TokenTree};
+use pm::{Delimiter, Level, LineColumn, Spacing};
+use pm::bridge::{server, TokenTree};
use std::{ascii, panic};
use std::ops::Bound;
@@ -51,7 +52,7 @@ impl FromInternal<(TreeAndJoint, &'_ ParseSess, &'_ mut Vec<Self>)>
{
fn from_internal(((tree, is_joint), sess, stack): (TreeAndJoint, &ParseSess, &mut Vec<Self>))
-> Self {
- use crate::parse::token::*;
+ use syntax::parse::token::*;
let joint = is_joint == Joint;
let Token { kind, span } = match tree {
@@ -192,7 +193,7 @@ impl FromInternal<(TreeAndJoint, &'_ ParseSess, &'_ mut Vec<Self>)>
impl ToInternal<TokenStream> for TokenTree<Group, Punct, Ident, Literal> {
fn to_internal(self) -> TokenStream {
- use crate::parse::token::*;
+ use syntax::parse::token::*;
let (ch, joint, span) = match self {
TokenTree::Punct(Punct { ch, joint, span }) => (ch, joint, span),
diff --git a/src/libsyntax_ext/Cargo.toml b/src/libsyntax_ext/Cargo.toml
index 73310df305b32..440873f3c2b2d 100644
--- a/src/libsyntax_ext/Cargo.toml
+++ b/src/libsyntax_ext/Cargo.toml
@@ -17,4 +17,5 @@ rustc_data_structures = { path = "../librustc_data_structures" }
rustc_target = { path = "../librustc_target" }
smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
syntax = { path = "../libsyntax" }
+syntax_expand = { path = "../libsyntax_expand" }
syntax_pos = { path = "../libsyntax_pos" }
diff --git a/src/libsyntax_ext/asm.rs b/src/libsyntax_ext/asm.rs
index becbf6d60a070..8c9a34713ea60 100644
--- a/src/libsyntax_ext/asm.rs
+++ b/src/libsyntax_ext/asm.rs
@@ -7,7 +7,7 @@ use rustc_data_structures::thin_vec::ThinVec;
use errors::DiagnosticBuilder;
use syntax::ast;
-use syntax::ext::base::{self, *};
+use syntax_expand::base::{self, *};
use syntax::parse::token::{self, Token};
use syntax::ptr::P;
use syntax::symbol::{kw, sym, Symbol};
diff --git a/src/libsyntax_ext/assert.rs b/src/libsyntax_ext/assert.rs
index cbfe14fa439be..f4d1f7fb09cdf 100644
--- a/src/libsyntax_ext/assert.rs
+++ b/src/libsyntax_ext/assert.rs
@@ -1,7 +1,7 @@
use errors::{Applicability, DiagnosticBuilder};
use syntax::ast::{self, *};
-use syntax::ext::base::*;
+use syntax_expand::base::*;
use syntax::parse::token::{self, TokenKind};
use syntax::parse::parser::Parser;
use syntax::print::pprust;
diff --git a/src/libsyntax_ext/cfg.rs b/src/libsyntax_ext/cfg.rs
index 3c33baf95a597..9e693f29c5a3c 100644
--- a/src/libsyntax_ext/cfg.rs
+++ b/src/libsyntax_ext/cfg.rs
@@ -5,7 +5,7 @@
use errors::DiagnosticBuilder;
use syntax::ast;
-use syntax::ext::base::{self, *};
+use syntax_expand::base::{self, *};
use syntax::attr;
use syntax::tokenstream::TokenStream;
use syntax::parse::token;
diff --git a/src/libsyntax_ext/cmdline_attrs.rs b/src/libsyntax_ext/cmdline_attrs.rs
index 2c3159739e243..2d981526a3983 100644
--- a/src/libsyntax_ext/cmdline_attrs.rs
+++ b/src/libsyntax_ext/cmdline_attrs.rs
@@ -2,9 +2,9 @@
use syntax::ast::{self, AttrItem, AttrStyle};
use syntax::attr::mk_attr;
-use syntax::panictry;
use syntax::parse::{self, token};
use syntax::sess::ParseSess;
+use syntax_expand::panictry;
use syntax_pos::FileName;
pub fn inject(mut krate: ast::Crate, parse_sess: &ParseSess, attrs: &[String]) -> ast::Crate {
diff --git a/src/libsyntax_ext/compile_error.rs b/src/libsyntax_ext/compile_error.rs
index 24f3a66d4ae19..cd7f78e9e342d 100644
--- a/src/libsyntax_ext/compile_error.rs
+++ b/src/libsyntax_ext/compile_error.rs
@@ -1,6 +1,6 @@
// The compiler code necessary to support the compile_error! extension.
-use syntax::ext::base::{self, *};
+use syntax_expand::base::{self, *};
use syntax_pos::Span;
use syntax::tokenstream::TokenStream;
diff --git a/src/libsyntax_ext/concat.rs b/src/libsyntax_ext/concat.rs
index 790fdad5b3f58..47bade698a80a 100644
--- a/src/libsyntax_ext/concat.rs
+++ b/src/libsyntax_ext/concat.rs
@@ -1,5 +1,5 @@
use syntax::ast;
-use syntax::ext::base::{self, DummyResult};
+use syntax_expand::base::{self, DummyResult};
use syntax::symbol::Symbol;
use syntax::tokenstream::TokenStream;
diff --git a/src/libsyntax_ext/concat_idents.rs b/src/libsyntax_ext/concat_idents.rs
index f6747658c070e..a132a4136ea01 100644
--- a/src/libsyntax_ext/concat_idents.rs
+++ b/src/libsyntax_ext/concat_idents.rs
@@ -1,7 +1,7 @@
use rustc_data_structures::thin_vec::ThinVec;
use syntax::ast;
-use syntax::ext::base::{self, *};
+use syntax_expand::base::{self, *};
use syntax::parse::token::{self, Token};
use syntax::ptr::P;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/bounds.rs b/src/libsyntax_ext/deriving/bounds.rs
index d5b8a00c75b83..6a9b70920242f 100644
--- a/src/libsyntax_ext/deriving/bounds.rs
+++ b/src/libsyntax_ext/deriving/bounds.rs
@@ -3,7 +3,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::MetaItem;
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax_pos::Span;
pub fn expand_deriving_copy(cx: &mut ExtCtxt<'_>,
diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs
index 9ef2c033b0784..eb7d480aa9831 100644
--- a/src/libsyntax_ext/deriving/clone.rs
+++ b/src/libsyntax_ext/deriving/clone.rs
@@ -3,7 +3,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{self, Expr, GenericArg, Generics, ItemKind, MetaItem, VariantData};
-use syntax::ext::base::{Annotatable, ExtCtxt, SpecialDerives};
+use syntax_expand::base::{Annotatable, ExtCtxt, SpecialDerives};
use syntax::ptr::P;
use syntax::symbol::{kw, sym, Symbol};
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/cmp/eq.rs b/src/libsyntax_ext/deriving/cmp/eq.rs
index c92339dd2fbd5..92721dab8782a 100644
--- a/src/libsyntax_ext/deriving/cmp/eq.rs
+++ b/src/libsyntax_ext/deriving/cmp/eq.rs
@@ -3,7 +3,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{self, Ident, Expr, MetaItem, GenericArg};
-use syntax::ext::base::{Annotatable, ExtCtxt, SpecialDerives};
+use syntax_expand::base::{Annotatable, ExtCtxt, SpecialDerives};
use syntax::ptr::P;
use syntax::symbol::{sym, Symbol};
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/cmp/ord.rs b/src/libsyntax_ext/deriving/cmp/ord.rs
index 1f4f5aa37099f..3eeed95aff75d 100644
--- a/src/libsyntax_ext/deriving/cmp/ord.rs
+++ b/src/libsyntax_ext/deriving/cmp/ord.rs
@@ -3,7 +3,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{self, Expr, MetaItem};
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::sym;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/cmp/partial_eq.rs b/src/libsyntax_ext/deriving/cmp/partial_eq.rs
index 91e1e80e4fbfa..1615d99179281 100644
--- a/src/libsyntax_ext/deriving/cmp/partial_eq.rs
+++ b/src/libsyntax_ext/deriving/cmp/partial_eq.rs
@@ -3,7 +3,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{BinOpKind, Expr, MetaItem};
-use syntax::ext::base::{Annotatable, ExtCtxt, SpecialDerives};
+use syntax_expand::base::{Annotatable, ExtCtxt, SpecialDerives};
use syntax::ptr::P;
use syntax::symbol::sym;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/cmp/partial_ord.rs b/src/libsyntax_ext/deriving/cmp/partial_ord.rs
index 13d63aaf2a80c..af8aacc6eb9bd 100644
--- a/src/libsyntax_ext/deriving/cmp/partial_ord.rs
+++ b/src/libsyntax_ext/deriving/cmp/partial_ord.rs
@@ -5,7 +5,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{self, BinOpKind, Expr, MetaItem};
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::{sym, Symbol};
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/debug.rs b/src/libsyntax_ext/deriving/debug.rs
index 003c2423576eb..35298211e4d31 100644
--- a/src/libsyntax_ext/deriving/debug.rs
+++ b/src/libsyntax_ext/deriving/debug.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::thin_vec::ThinVec;
use syntax::ast::{self, Ident};
use syntax::ast::{Expr, MetaItem};
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::sym;
use syntax_pos::{DUMMY_SP, Span};
diff --git a/src/libsyntax_ext/deriving/decodable.rs b/src/libsyntax_ext/deriving/decodable.rs
index cde72abbdef6a..3a0379a0eb02b 100644
--- a/src/libsyntax_ext/deriving/decodable.rs
+++ b/src/libsyntax_ext/deriving/decodable.rs
@@ -6,7 +6,7 @@ use crate::deriving::generic::ty::*;
use syntax::ast;
use syntax::ast::{Expr, MetaItem, Mutability};
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::Symbol;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/default.rs b/src/libsyntax_ext/deriving/default.rs
index 2fdea10b76f51..6176791c31b18 100644
--- a/src/libsyntax_ext/deriving/default.rs
+++ b/src/libsyntax_ext/deriving/default.rs
@@ -3,7 +3,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{Expr, MetaItem};
-use syntax::ext::base::{Annotatable, DummyResult, ExtCtxt};
+use syntax_expand::base::{Annotatable, DummyResult, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::{kw, sym};
use syntax::span_err;
diff --git a/src/libsyntax_ext/deriving/encodable.rs b/src/libsyntax_ext/deriving/encodable.rs
index 655d3bb7c4ab8..2105946b666b2 100644
--- a/src/libsyntax_ext/deriving/encodable.rs
+++ b/src/libsyntax_ext/deriving/encodable.rs
@@ -90,7 +90,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{Expr, ExprKind, MetaItem, Mutability};
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::Symbol;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index 9c3ec06d59a34..1886a5154b7b6 100644
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -186,12 +186,12 @@ use rustc_target::spec::abi::Abi;
use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind};
use syntax::ast::{VariantData, GenericParamKind, GenericArg};
use syntax::attr;
-use syntax::ext::base::{Annotatable, ExtCtxt, SpecialDerives};
use syntax::source_map::respan;
use syntax::util::map_in_place::MapInPlace;
use syntax::ptr::P;
use syntax::sess::ParseSess;
use syntax::symbol::{Symbol, kw, sym};
+use syntax_expand::base::{Annotatable, ExtCtxt, SpecialDerives};
use syntax_pos::{Span};
use ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty};
diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs
index 6ae02a5cab199..607746597a592 100644
--- a/src/libsyntax_ext/deriving/generic/ty.rs
+++ b/src/libsyntax_ext/deriving/generic/ty.rs
@@ -5,7 +5,7 @@ pub use PtrTy::*;
pub use Ty::*;
use syntax::ast::{self, Expr, GenericParamKind, Generics, Ident, SelfKind, GenericArg};
-use syntax::ext::base::ExtCtxt;
+use syntax_expand::base::ExtCtxt;
use syntax::source_map::{respan, DUMMY_SP};
use syntax::ptr::P;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/hash.rs b/src/libsyntax_ext/deriving/hash.rs
index 2fc594abd705e..fe9ef78bb1b00 100644
--- a/src/libsyntax_ext/deriving/hash.rs
+++ b/src/libsyntax_ext/deriving/hash.rs
@@ -3,7 +3,7 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*;
use syntax::ast::{Expr, MetaItem, Mutability};
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::sym;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs
index 60b6eba7a4b53..f0471a857dc93 100644
--- a/src/libsyntax_ext/deriving/mod.rs
+++ b/src/libsyntax_ext/deriving/mod.rs
@@ -1,7 +1,7 @@
//! The compiler code necessary to implement the `#[derive]` extensions.
use syntax::ast::{self, MetaItem};
-use syntax::ext::base::{Annotatable, ExtCtxt, MultiItemModifier};
+use syntax_expand::base::{Annotatable, ExtCtxt, MultiItemModifier};
use syntax::ptr::P;
use syntax::symbol::{Symbol, sym};
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs
index 02757bf6b1689..58fe56bd2353a 100644
--- a/src/libsyntax_ext/env.rs
+++ b/src/libsyntax_ext/env.rs
@@ -4,7 +4,7 @@
//
use syntax::ast::{self, Ident, GenericArg};
-use syntax::ext::base::{self, *};
+use syntax_expand::base::{self, *};
use syntax::symbol::{kw, sym, Symbol};
use syntax_pos::Span;
use syntax::tokenstream::TokenStream;
diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs
index 8fc64021b51fc..45d9f79c28fc3 100644
--- a/src/libsyntax_ext/format.rs
+++ b/src/libsyntax_ext/format.rs
@@ -8,7 +8,7 @@ use errors::Applicability;
use errors::pluralise;
use syntax::ast;
-use syntax::ext::base::{self, *};
+use syntax_expand::base::{self, *};
use syntax::parse::token;
use syntax::ptr::P;
use syntax::symbol::{Symbol, sym};
diff --git a/src/libsyntax_ext/global_allocator.rs b/src/libsyntax_ext/global_allocator.rs
index cd2a9b61a76df..75dda9535b333 100644
--- a/src/libsyntax_ext/global_allocator.rs
+++ b/src/libsyntax_ext/global_allocator.rs
@@ -1,8 +1,9 @@
+use crate::util::check_builtin_macro_attribute;
+
use syntax::ast::{ItemKind, Mutability, Stmt, Ty, TyKind, Unsafety};
use syntax::ast::{self, Param, Attribute, Expr, FnHeader, Generics, Ident};
-use syntax::attr::check_builtin_macro_attribute;
-use syntax::ext::allocator::{AllocatorKind, AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS};
-use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax_expand::allocator::{AllocatorKind, AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::{kw, sym, Symbol};
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/global_asm.rs b/src/libsyntax_ext/global_asm.rs
index 72fb5b47c2154..879ae1e42153d 100644
--- a/src/libsyntax_ext/global_asm.rs
+++ b/src/libsyntax_ext/global_asm.rs
@@ -12,7 +12,7 @@ use errors::DiagnosticBuilder;
use syntax::ast;
use syntax::source_map::respan;
-use syntax::ext::base::{self, *};
+use syntax_expand::base::{self, *};
use syntax::parse::token;
use syntax::ptr::P;
use syntax_pos::Span;
diff --git a/src/libsyntax_ext/lib.rs b/src/libsyntax_ext/lib.rs
index 64d46a84cba47..5516f276422e9 100644
--- a/src/libsyntax_ext/lib.rs
+++ b/src/libsyntax_ext/lib.rs
@@ -15,9 +15,9 @@ use crate::deriving::*;
use syntax::ast::Ident;
use syntax::edition::Edition;
-use syntax::ext::base::{SyntaxExtension, SyntaxExtensionKind, MacroExpanderFn};
-use syntax::ext::proc_macro::BangProcMacro;
use syntax::symbol::sym;
+use syntax_expand::base::{Resolver, SyntaxExtension, SyntaxExtensionKind, MacroExpanderFn};
+use syntax_expand::proc_macro::BangProcMacro;
mod error_codes;
@@ -37,6 +37,7 @@ mod log_syntax;
mod source_util;
mod test;
mod trace_macros;
+mod util;
pub mod cmdline_attrs;
pub mod plugin_macro_defs;
@@ -44,7 +45,7 @@ pub mod proc_macro_harness;
pub mod standard_library_imports;
pub mod test_harness;
-pub fn register_builtin_macros(resolver: &mut dyn syntax::ext::base::Resolver, edition: Edition) {
+pub fn register_builtin_macros(resolver: &mut dyn Resolver, edition: Edition) {
let mut register = |name, kind| resolver.register_builtin_macro(
Ident::with_dummy_span(name), SyntaxExtension {
is_builtin: true, ..SyntaxExtension::default(kind, edition)
diff --git a/src/libsyntax_ext/log_syntax.rs b/src/libsyntax_ext/log_syntax.rs
index 92130bfaf68e3..2202375e5e780 100644
--- a/src/libsyntax_ext/log_syntax.rs
+++ b/src/libsyntax_ext/log_syntax.rs
@@ -1,4 +1,4 @@
-use syntax::ext::base;
+use syntax_expand::base;
use syntax::print;
use syntax::tokenstream::TokenStream;
use syntax_pos;
diff --git a/src/libsyntax_ext/plugin_macro_defs.rs b/src/libsyntax_ext/plugin_macro_defs.rs
index 62c7e188eba27..1ca9422eb9dcc 100644
--- a/src/libsyntax_ext/plugin_macro_defs.rs
+++ b/src/libsyntax_ext/plugin_macro_defs.rs
@@ -4,7 +4,7 @@
use syntax::ast::*;
use syntax::attr;
use syntax::edition::Edition;
-use syntax::ext::base::{Resolver, NamedSyntaxExtension};
+use syntax_expand::base::{Resolver, NamedSyntaxExtension};
use syntax::parse::token;
use syntax::ptr::P;
use syntax::source_map::respan;
diff --git a/src/libsyntax_ext/proc_macro_harness.rs b/src/libsyntax_ext/proc_macro_harness.rs
index 1b7068818b014..96d0c3fcab1c5 100644
--- a/src/libsyntax_ext/proc_macro_harness.rs
+++ b/src/libsyntax_ext/proc_macro_harness.rs
@@ -3,14 +3,14 @@ use std::mem;
use smallvec::smallvec;
use syntax::ast::{self, Ident};
use syntax::attr;
-use syntax::ext::base::ExtCtxt;
-use syntax::ext::expand::{AstFragment, ExpansionConfig};
-use syntax::ext::proc_macro::is_proc_macro_attr;
use syntax::print::pprust;
use syntax::ptr::P;
use syntax::sess::ParseSess;
use syntax::symbol::{kw, sym};
use syntax::visit::{self, Visitor};
+use syntax_expand::base::{ExtCtxt, Resolver};
+use syntax_expand::expand::{AstFragment, ExpansionConfig};
+use syntax_expand::proc_macro::is_proc_macro_attr;
use syntax_pos::{Span, DUMMY_SP};
use syntax_pos::hygiene::AstPass;
@@ -46,7 +46,7 @@ struct CollectProcMacros<'a> {
}
pub fn inject(sess: &ParseSess,
- resolver: &mut dyn (::syntax::ext::base::Resolver),
+ resolver: &mut dyn Resolver,
mut krate: ast::Crate,
is_proc_macro_crate: bool,
has_proc_macro_decls: bool,
diff --git a/src/libsyntax_ext/source_util.rs b/src/libsyntax_ext/source_util.rs
index f74507dcc21f6..438e199ebdb8f 100644
--- a/src/libsyntax_ext/source_util.rs
+++ b/src/libsyntax_ext/source_util.rs
@@ -1,5 +1,6 @@
-use syntax::{ast, panictry};
-use syntax::ext::base::{self, *};
+use syntax_expand::panictry;
+use syntax_expand::base::{self, *};
+use syntax::ast;
use syntax::parse::{self, token, DirectoryOwnership};
use syntax::print::pprust;
use syntax::ptr::P;
diff --git a/src/libsyntax_ext/standard_library_imports.rs b/src/libsyntax_ext/standard_library_imports.rs
index 4f17acf2d0f66..fd27a21890698 100644
--- a/src/libsyntax_ext/standard_library_imports.rs
+++ b/src/libsyntax_ext/standard_library_imports.rs
@@ -1,11 +1,11 @@
use syntax::{ast, attr};
use syntax::edition::Edition;
-use syntax::ext::expand::ExpansionConfig;
-use syntax::ext::hygiene::AstPass;
-use syntax::ext::base::{ExtCtxt, Resolver};
use syntax::ptr::P;
use syntax::sess::ParseSess;
use syntax::symbol::{Ident, Symbol, kw, sym};
+use syntax_expand::expand::ExpansionConfig;
+use syntax_expand::hygiene::AstPass;
+use syntax_expand::base::{ExtCtxt, Resolver};
use syntax_pos::DUMMY_SP;
pub fn inject(
diff --git a/src/libsyntax_ext/test.rs b/src/libsyntax_ext/test.rs
index d4638c45473b1..b0da413d63a04 100644
--- a/src/libsyntax_ext/test.rs
+++ b/src/libsyntax_ext/test.rs
@@ -1,9 +1,11 @@
/// The expansion from a test function to the appropriate test struct for libtest
/// Ideally, this code would be in libtest but for efficiency and error messages it lives here.
+use crate::util::check_builtin_macro_attribute;
+
use syntax::ast;
-use syntax::attr::{self, check_builtin_macro_attribute};
-use syntax::ext::base::*;
+use syntax::attr;
+use syntax_expand::base::*;
use syntax::print::pprust;
use syntax::source_map::respan;
use syntax::symbol::{Symbol, sym};
diff --git a/src/libsyntax_ext/test_harness.rs b/src/libsyntax_ext/test_harness.rs
index 0bb279c0cb0d2..33d41a7f53e5e 100644
--- a/src/libsyntax_ext/test_harness.rs
+++ b/src/libsyntax_ext/test_harness.rs
@@ -6,8 +6,8 @@ use rustc_target::spec::PanicStrategy;
use syntax::ast::{self, Ident};
use syntax::attr;
use syntax::entry::{self, EntryPointType};
-use syntax::ext::base::{ExtCtxt, Resolver};
-use syntax::ext::expand::{AstFragment, ExpansionConfig};
+use syntax_expand::base::{ExtCtxt, Resolver};
+use syntax_expand::expand::{AstFragment, ExpansionConfig};
use syntax::feature_gate::Features;
use syntax::mut_visit::{*, ExpectOne};
use syntax::ptr::P;
diff --git a/src/libsyntax_ext/trace_macros.rs b/src/libsyntax_ext/trace_macros.rs
index d83c24046d9e5..dbf96d3b561a9 100644
--- a/src/libsyntax_ext/trace_macros.rs
+++ b/src/libsyntax_ext/trace_macros.rs
@@ -1,4 +1,4 @@
-use syntax::ext::base::{self, ExtCtxt};
+use syntax_expand::base::{self, ExtCtxt};
use syntax::symbol::kw;
use syntax_pos::Span;
use syntax::tokenstream::{TokenTree, TokenStream};
diff --git a/src/libsyntax_ext/util.rs b/src/libsyntax_ext/util.rs
new file mode 100644
index 0000000000000..d84fe19b3eab2
--- /dev/null
+++ b/src/libsyntax_ext/util.rs
@@ -0,0 +1,11 @@
+use syntax_pos::Symbol;
+use syntax::ast::MetaItem;
+use syntax::attr::{check_builtin_attribute, AttributeTemplate};
+use syntax_expand::base::ExtCtxt;
+
+pub fn check_builtin_macro_attribute(ecx: &ExtCtxt<'_>, meta_item: &MetaItem, name: Symbol) {
+ // All the built-in macro attributes are "words" at the moment.
+ let template = AttributeTemplate::only_word();
+ let attr = ecx.attribute(meta_item.clone());
+ check_builtin_attribute(ecx.parse_sess, &attr, name, template);
+}
diff --git a/src/test/ui-fulldeps/ast_stmt_expr_attr.rs b/src/test/ui-fulldeps/ast_stmt_expr_attr.rs
index 5479119d812f8..927e2c0820eb2 100644
--- a/src/test/ui-fulldeps/ast_stmt_expr_attr.rs
+++ b/src/test/ui-fulldeps/ast_stmt_expr_attr.rs
@@ -18,7 +18,7 @@ use syntax::parse::new_parser_from_source_str;
use syntax::parse::parser::Parser;
use syntax::parse::token;
use syntax::ptr::P;
-use syntax::parse::attr::*;
+use syntax::parse::parser::attr::*;
use syntax::print::pprust;
use std::fmt;
diff --git a/src/test/ui-fulldeps/auxiliary/attr-plugin-test.rs b/src/test/ui-fulldeps/auxiliary/attr-plugin-test.rs
index c053c71524876..3d08c1c9eeefa 100644
--- a/src/test/ui-fulldeps/auxiliary/attr-plugin-test.rs
+++ b/src/test/ui-fulldeps/auxiliary/attr-plugin-test.rs
@@ -5,9 +5,10 @@
extern crate rustc_driver;
extern crate syntax;
+extern crate syntax_expand;
use rustc_driver::plugin::Registry;
-use syntax::ext::base::SyntaxExtension;
+use syntax_expand::base::SyntaxExtension;
use syntax::feature_gate::AttributeType;
use syntax::symbol::Symbol;
diff --git a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs
index 6fb99b2c98361..bb0ebf693d0be 100644
--- a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs
+++ b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs
@@ -5,10 +5,11 @@
extern crate rustc;
extern crate rustc_driver;
extern crate syntax;
+extern crate syntax_expand;
use rustc_driver::plugin::Registry;
use syntax::attr;
-use syntax::ext::base::*;
+use syntax_expand::base::*;
use syntax::feature_gate::AttributeType::Whitelisted;
use syntax::symbol::Symbol;
diff --git a/src/test/ui-fulldeps/auxiliary/plugin-args.rs b/src/test/ui-fulldeps/auxiliary/plugin-args.rs
index 5ff24cff23c55..cccdfea208327 100644
--- a/src/test/ui-fulldeps/auxiliary/plugin-args.rs
+++ b/src/test/ui-fulldeps/auxiliary/plugin-args.rs
@@ -4,14 +4,15 @@
#![feature(box_syntax, rustc_private)]
extern crate syntax;
+extern crate syntax_expand;
extern crate syntax_pos;
extern crate rustc;
extern crate rustc_driver;
use std::borrow::ToOwned;
use syntax::ast;
-use syntax::ext::base::{SyntaxExtension, SyntaxExtensionKind};
-use syntax::ext::base::{TTMacroExpander, ExtCtxt, MacResult, MacEager};
+use syntax_expand::base::{SyntaxExtension, SyntaxExtensionKind};
+use syntax_expand::base::{TTMacroExpander, ExtCtxt, MacResult, MacEager};
use syntax::print::pprust;
use syntax::symbol::Symbol;
use syntax_pos::Span;
diff --git a/src/test/ui-fulldeps/auxiliary/roman-numerals.rs b/src/test/ui-fulldeps/auxiliary/roman-numerals.rs
index 2b57e9289b525..3524f449c7452 100644
--- a/src/test/ui-fulldeps/auxiliary/roman-numerals.rs
+++ b/src/test/ui-fulldeps/auxiliary/roman-numerals.rs
@@ -10,13 +10,14 @@
#![feature(plugin_registrar, rustc_private)]
extern crate syntax;
+extern crate syntax_expand;
extern crate syntax_pos;
extern crate rustc;
extern crate rustc_driver;
use syntax::parse::token::{self, Token};
use syntax::tokenstream::{TokenTree, TokenStream};
-use syntax::ext::base::{ExtCtxt, MacResult, DummyResult, MacEager};
+use syntax_expand::base::{ExtCtxt, MacResult, DummyResult, MacEager};
use syntax_pos::Span;
use rustc_driver::plugin::Registry;
diff --git a/src/test/ui/ufcs/ufcs-partially-resolved.stderr b/src/test/ui/ufcs/ufcs-partially-resolved.stderr
index 5ee8adaaf270f..39752f66b9d65 100644
--- a/src/test/ui/ufcs/ufcs-partially-resolved.stderr
+++ b/src/test/ui/ufcs/ufcs-partially-resolved.stderr
@@ -200,5 +200,5 @@ LL | <u8 as Dr>::X::N;
error: aborting due to 32 previous errors
-Some errors have detailed explanations: E0223, E0433, E0599.
+Some errors have detailed explanations: E0223, E0433, E0575, E0599.
For more information about an error, try `rustc --explain E0223`.