"serialize",
"smallvec",
"syntax",
- "syntax_expand",
"syntax_pos",
]
"rustc_target",
"serialize",
"syntax",
- "syntax_expand",
"syntax_pos",
"tempfile",
]
"rustc_index",
"rustc_target",
"syntax",
- "syntax_expand",
"syntax_pos",
]
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"
use crate::util::nodemap::DefIdMap;
use syntax::ast;
-use syntax_expand::base::MacroKind;
use syntax::ast::NodeId;
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::Span;
use rustc_macros::HashStable;
use syntax::ptr::P as AstP;
use syntax::ast::*;
use syntax::errors;
-use syntax_expand::base::SpecialDerives;
+use syntax::expand::SpecialDerives;
use syntax::print::pprust;
use syntax::parse::token::{self, Nonterminal, Token};
use syntax::tokenstream::{TokenStream, TokenTree};
use syntax::attr;
use syntax::ast::*;
use syntax::visit::{self, Visitor};
-use syntax_expand::base::SpecialDerives;
+use syntax::expand::SpecialDerives;
use syntax::source_map::{respan, DesugaringKind, Spanned};
use syntax::symbol::{kw, sym};
use syntax_pos::Span;
use crate::hir::def_id::DefIndex;
use syntax::ast::*;
-use syntax_expand::hygiene::ExpnId;
use syntax::visit;
use syntax::symbol::{kw, sym};
use syntax::parse::token::{self, Token};
+use syntax_pos::hygiene::ExpnId;
use syntax_pos::Span;
/// Creates `DefId`s for nodes in the AST.
use std::fmt::Write;
use std::hash::Hash;
use syntax::ast;
-use syntax_expand::hygiene::ExpnId;
-use syntax::symbol::{Symbol, sym};
+use syntax_pos::symbol::{Symbol, sym};
+use syntax_pos::hygiene::ExpnId;
use syntax_pos::{Span, DUMMY_SP};
/// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa.
use rustc_index::vec::IndexVec;
use syntax::ast::{self, Name, NodeId};
use syntax::source_map::Spanned;
-use syntax_expand::base::MacroKind;
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::{Span, DUMMY_SP};
pub mod blocks;
use syntax::ast;
use syntax::source_map::SourceMap;
-use syntax_expand::hygiene::SyntaxContext;
use syntax::symbol::Symbol;
use syntax::tokenstream::DelimSpan;
use syntax_pos::{Span, DUMMY_SP};
-use syntax_pos::hygiene;
+use syntax_pos::hygiene::{self, SyntaxContext};
use rustc_data_structures::stable_hasher::{
HashStable, StableHasher, ToStableHashKey,
Intel
});
-impl_stable_hash_for!(enum ::syntax_expand::base::MacroKind {
+impl_stable_hash_for!(enum ::syntax_pos::hygiene::MacroKind {
Bang,
Attr,
Derive,
use syntax::source_map::{MultiSpan, ExpnKind, DesugaringKind};
use syntax::early_buffered_lints::BufferedEarlyLintId;
use syntax::edition::Edition;
-use syntax_expand::base::MacroKind;
use syntax::symbol::{Symbol, sym};
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::Span;
pub use crate::lint::context::{LateContext, EarlyContext, LintContext, LintStore,
use errors::annotate_snippet_emitter_writer::{AnnotateSnippetEmitterWriter};
use syntax::ast::{self, NodeId};
use syntax::edition::Edition;
-use syntax_expand::allocator::AllocatorKind;
+use syntax::expand::allocator::AllocatorKind;
use syntax::feature_gate::{self, AttributeType};
use syntax::json::JsonEmitter;
use syntax::source_map;
use std::ops::Range;
use syntax::ast::{self, Name, Ident, NodeId};
use syntax::attr;
-use syntax_expand::hygiene::ExpnId;
-use syntax::symbol::{kw, sym, Symbol};
+use syntax_pos::symbol::{kw, sym, Symbol};
+use syntax_pos::hygiene::ExpnId;
use syntax_pos::Span;
use smallvec;
use crate::attributes;
use libc::c_uint;
use rustc::ty::TyCtxt;
-use syntax_expand::allocator::{AllocatorKind, AllocatorTy, ALLOCATOR_METHODS};
+use syntax::expand::allocator::{AllocatorKind, AllocatorTy, ALLOCATOR_METHODS};
use crate::ModuleLlvm;
use crate::llvm::{self, False, True};
#[macro_use] extern crate log;
extern crate syntax;
-extern crate syntax_expand;
extern crate syntax_pos;
extern crate rustc_errors as errors;
use rustc_codegen_ssa::CompiledModule;
use errors::{FatalError, Handler};
use rustc::dep_graph::WorkProduct;
-use syntax_expand::allocator::AllocatorKind;
+use syntax::expand::allocator::AllocatorKind;
pub use llvm_util::target_features;
use std::any::Any;
use std::sync::Arc;
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" }
use rustc::ty::subst::SubstsRef;
use rustc::util::nodemap::{FxHashMap, DefIdMap};
use rustc_index::vec::IndexVec;
-use syntax_expand::allocator::ALLOCATOR_METHODS;
+use syntax::expand::allocator::ALLOCATOR_METHODS;
pub type ExportedSymbols = FxHashMap<
CrateNum,
use rustc_errors::emitter::{Emitter};
use rustc_target::spec::MergeFunctions;
use syntax::attr;
-use syntax_expand::hygiene::ExpnId;
+use syntax_pos::hygiene::ExpnId;
use syntax_pos::symbol::{Symbol, sym};
use jobserver::{Client, Acquired};
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use std::sync::Arc;
use std::sync::mpsc;
-use syntax_expand::allocator::AllocatorKind;
+use syntax::expand::allocator::AllocatorKind;
use syntax_pos::symbol::Symbol;
pub trait BackendTypes {
// Discard hygiene data, which isn't required after lowering to HIR.
if !sess.opts.debugging_opts.keep_hygiene_data {
- syntax_expand::hygiene::clear_syntax_context_map();
+ syntax_pos::hygiene::clear_syntax_context_map();
}
Ok(hir_forest)
use syntax::ast;
use syntax::attr;
-use syntax_expand::allocator::{global_allocator_spans, AllocatorKind};
+use syntax::expand::allocator::{global_allocator_spans, AllocatorKind};
use syntax::symbol::{Symbol, sym};
use syntax::span_fatal;
use syntax_pos::{Span, DUMMY_SP};
use syntax::attr;
use syntax::ast::{self, Ident};
use syntax::source_map::{self, respan, Spanned};
-use syntax::symbol::{Symbol, sym};
-use syntax_expand::base::{MacroKind, SyntaxExtensionKind, SyntaxExtension};
-use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP};
+use syntax_expand::base::{SyntaxExtensionKind, SyntaxExtension};
+use syntax_expand::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro};
+use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, hygiene::MacroKind};
+use syntax_pos::symbol::{Symbol, sym};
use log::debug;
use proc_macro::bridge::client::ProcMacro;
-use syntax_expand::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro};
crate struct DecodeContext<'a, 'tcx> {
opaque: opaque::Decoder<'a>,
use std::u32;
use syntax::ast;
use syntax::attr;
-use syntax_expand::proc_macro::is_proc_macro_attr;
+use syntax::expand::is_proc_macro_attr;
use syntax::source_map::Spanned;
use syntax::symbol::{kw, sym, Ident, Symbol};
use syntax_pos::{self, FileName, SourceFile, Span};
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" }
use rustc_data_structures::fx::FxHashMap;
use syntax::ast::*;
use syntax::attr;
-use syntax_expand::proc_macro::is_proc_macro_attr;
+use syntax::expand::is_proc_macro_attr;
use syntax::feature_gate::is_builtin_attr;
use syntax::source_map::Spanned;
use syntax::symbol::{kw, sym};
use syntax::ast::{self, Block, ForeignItem, ForeignItemKind, Item, ItemKind, NodeId};
use syntax::ast::{MetaItemKind, StmtKind, TraitItem, TraitItemKind};
-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;
use syntax::source_map::{respan, Spanned};
use syntax::symbol::{kw, sym};
use syntax::visit::{self, Visitor};
-
+use syntax_expand::base::SyntaxExtension;
+use syntax_expand::expand::AstFragment;
+use syntax_pos::hygiene::{MacroKind, ExpnId};
use syntax_pos::{Span, DUMMY_SP};
use log::debug;
use rustc::ty::{self, DefIdTree};
use rustc::util::nodemap::FxHashSet;
use syntax::ast::{self, Ident, Path};
-use syntax_expand::base::MacroKind;
use syntax::feature_gate::BUILTIN_ATTRIBUTES;
use syntax::source_map::SourceMap;
use syntax::struct_span_err;
use syntax::symbol::{Symbol, kw};
use syntax::util::lev_distance::find_best_match_for_name;
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::{BytePos, Span, MultiSpan};
use crate::resolve_imports::{ImportDirective, ImportDirectiveSubclass, ImportResolver};
use rustc::session::config::nightly_options;
use rustc::util::nodemap::FxHashSet;
use syntax::ast::{self, Expr, ExprKind, Ident, NodeId, Path, Ty, TyKind};
-use syntax_expand::base::MacroKind;
use syntax::symbol::kw;
use syntax::util::lev_distance::find_best_match_for_name;
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::Span;
type Res = def::Res<ast::NodeId>;
use rustc_metadata::creader::CrateLoader;
use rustc_metadata::cstore::CStore;
-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::expand::SpecialDerives;
use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
-use syntax::ast::{ItemKind, Path, CRATE_NODE_ID, Crate};
+use syntax::ast::{CRATE_NODE_ID, Crate};
+use syntax::ast::{ItemKind, Path};
+use syntax::attr;
use syntax::print::pprust;
use syntax::symbol::{kw, sym};
use syntax::source_map::Spanned;
use syntax::visit::{self, Visitor};
-
+use syntax_expand::base::SyntaxExtension;
+use syntax_pos::hygiene::{MacroKind, ExpnId, Transparency, SyntaxContext};
use syntax_pos::{Span, DUMMY_SP};
use errors::{Applicability, DiagnosticBuilder};
use syntax::ast::{self, NodeId, Ident};
use syntax::attr::StabilityLevel;
use syntax::edition::Edition;
-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::expand::SpecialDerives;
use syntax::feature_gate::{emit_feature_err, is_builtin_attr_name};
use syntax::feature_gate::GateIssue;
use syntax::print::pprust;
use syntax::symbol::{Symbol, kw, sym};
+use syntax_expand::base::{self, InvocationRes, Indeterminate};
+use syntax_expand::base::SyntaxExtension;
+use syntax_expand::expand::{AstFragment, AstFragmentKind, Invocation, InvocationKind};
+use syntax_expand::compile_declarative_macro;
+use syntax_pos::hygiene::{self, ExpnId, ExpnData, ExpnKind};
use syntax_pos::{Span, DUMMY_SP};
use std::{mem, ptr};
use rustc_data_structures::sync::Lrc;
-use syntax_pos::hygiene::AstPass;
+use syntax_pos::hygiene::{MacroKind, AstPass};
type Res = def::Res<NodeId>;
use rustc::{bug, span_bug};
use syntax::ast::{Ident, Name, NodeId, CRATE_NODE_ID};
-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};
+use syntax_pos::hygiene::ExpnId;
use syntax_pos::{MultiSpan, Span};
use log::*;
use std::iter::once;
use syntax::ast;
-use syntax_expand::base::MacroKind;
use syntax::symbol::sym;
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::Span;
use rustc::hir;
use rustc::util::nodemap::{FxHashMap, FxHashSet};
use syntax::ast::{self, Attribute, AttrStyle, AttrItem, Ident};
use syntax::attr;
-use syntax_expand::base::MacroKind;
use syntax::parse::lexer::comments;
use syntax::source_map::DUMMY_SP;
-use syntax::symbol::{Symbol, kw, sym};
+use syntax_pos::symbol::{Symbol, kw, sym};
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::{self, Pos, FileName};
use std::collections::hash_map::Entry;
use syntax::ast;
use syntax::ast::Name;
-use syntax_expand::base::MacroKind;
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::{self, Span};
use rustc::hir;
//! Item types.
use std::fmt;
-use syntax_expand::base::MacroKind;
+use syntax_pos::hygiene::MacroKind;
use crate::clean;
/// Item type. Corresponds to `clean::ItemEnum` variants.
use syntax::print::pprust;
use syntax::source_map::FileName;
use syntax::symbol::{Symbol, sym};
-use syntax_expand::base::MacroKind;
+use syntax_pos::hygiene::MacroKind;
use rustc::hir::def_id::DefId;
use rustc::middle::privacy::AccessLevels;
use rustc::middle::stability;
use rustc::util::nodemap::{FxHashSet, FxHashMap};
use rustc::ty::TyCtxt;
use syntax::ast;
-use syntax_expand::base::MacroKind;
use syntax::source_map::Spanned;
use syntax::symbol::sym;
+use syntax_pos::hygiene::MacroKind;
use syntax_pos::{self, Span};
use std::mem;
use crate::mut_visit::visit_clobber;
use crate::source_map::{BytePos, Spanned};
use crate::parse::lexer::comments::doc_comment_style;
-use crate::parse::parser::Parser;
+use crate::parse;
use crate::parse::PResult;
use crate::parse::token::{self, Token};
use crate::ptr::P;
self.item.meta(self.span)
}
- 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(
- sess,
- self.tokens.clone(),
- None,
- false,
- false,
- Some("attribute"),
- );
- let result = f(&mut parser)?;
- if parser.token != token::Eof {
- parser.unexpected()?;
- }
- Ok(result)
- }
-
- 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, |p| p.parse_derive_paths())
- }
-
pub fn parse_meta<'a>(&self, sess: &'a ParseSess) -> PResult<'a, MetaItem> {
Ok(MetaItem {
path: self.path.clone(),
- kind: self.parse(sess, |parser| parser.parse_meta_item_kind())?,
+ kind: parse::parse_in_attr(sess, self, |p| p.parse_meta_item_kind())?,
span: self.span,
})
}
use crate::ast;
use crate::edition::Edition;
use crate::mut_visit::*;
+use crate::parse;
use crate::ptr::P;
use crate::sess::ParseSess;
use crate::symbol::sym;
return vec![];
}
- let (cfg_predicate, expanded_attrs) = match attr.parse(self.sess, |p| p.parse_cfg_attr()) {
+ let res = parse::parse_in_attr(self.sess, &attr, |p| p.parse_cfg_attr());
+ let (cfg_predicate, expanded_attrs) = match res {
Ok(result) => result,
Err(mut e) => {
e.emit();
--- /dev/null
+use crate::{ast, attr, visit};
+use syntax_pos::symbol::{sym, Symbol};
+use syntax_pos::Span;
+
+#[derive(Clone, Copy)]
+pub enum AllocatorKind {
+ Global,
+ DefaultLib,
+ DefaultExe,
+}
+
+impl AllocatorKind {
+ pub fn fn_name(&self, base: &str) -> String {
+ match *self {
+ AllocatorKind::Global => format!("__rg_{}", base),
+ AllocatorKind::DefaultLib => format!("__rdl_{}", base),
+ AllocatorKind::DefaultExe => format!("__rde_{}", base),
+ }
+ }
+}
+
+pub enum AllocatorTy {
+ Layout,
+ Ptr,
+ ResultPtr,
+ Unit,
+ Usize,
+}
+
+pub struct AllocatorMethod {
+ pub name: &'static str,
+ pub inputs: &'static [AllocatorTy],
+ pub output: AllocatorTy,
+}
+
+pub static ALLOCATOR_METHODS: &[AllocatorMethod] = &[
+ AllocatorMethod {
+ name: "alloc",
+ inputs: &[AllocatorTy::Layout],
+ output: AllocatorTy::ResultPtr,
+ },
+ AllocatorMethod {
+ name: "dealloc",
+ inputs: &[AllocatorTy::Ptr, AllocatorTy::Layout],
+ output: AllocatorTy::Unit,
+ },
+ AllocatorMethod {
+ name: "realloc",
+ inputs: &[AllocatorTy::Ptr, AllocatorTy::Layout, AllocatorTy::Usize],
+ output: AllocatorTy::ResultPtr,
+ },
+ AllocatorMethod {
+ name: "alloc_zeroed",
+ inputs: &[AllocatorTy::Layout],
+ output: AllocatorTy::ResultPtr,
+ },
+];
+
+pub fn global_allocator_spans(krate: &ast::Crate) -> Vec<Span> {
+ struct Finder { name: Symbol, spans: Vec<Span> }
+ impl<'ast> visit::Visitor<'ast> for Finder {
+ fn visit_item(&mut self, item: &'ast ast::Item) {
+ if item.ident.name == self.name &&
+ attr::contains_name(&item.attrs, sym::rustc_std_internal_symbol) {
+ self.spans.push(item.span);
+ }
+ visit::walk_item(self, item)
+ }
+ }
+
+ let name = Symbol::intern(&AllocatorKind::Global.fn_name("alloc"));
+ let mut f = Finder { name, spans: Vec::new() };
+ visit::walk_crate(&mut f, krate);
+ f.spans
+}
--- /dev/null
+//! Definitions shared by macros / syntax extensions and e.g. librustc.
+
+use crate::ast::Attribute;
+use syntax_pos::symbol::sym;
+
+pub mod allocator;
+
+bitflags::bitflags! {
+ /// Built-in derives that need some extra tracking beyond the usual macro functionality.
+ #[derive(Default)]
+ pub struct SpecialDerives: u8 {
+ const PARTIAL_EQ = 1 << 0;
+ const EQ = 1 << 1;
+ const COPY = 1 << 2;
+ }
+}
+
+pub fn is_proc_macro_attr(attr: &Attribute) -> bool {
+ [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
+ .iter().any(|kind| attr.check_name(*kind))
+}
pub mod ast;
pub mod attr;
+pub mod expand;
pub mod source_map;
-#[macro_use]
-pub mod config;
+#[macro_use] pub mod config;
pub mod entry;
pub mod feature_gate;
pub mod mut_visit;
Parser::new(sess, stream, Some(base_dir), true, false, None)
}
+/// Runs the given subparser `f` on the tokens of the given `attr`'s item.
+pub fn parse_in_attr<'a, T>(
+ sess: &'a ParseSess,
+ attr: &ast::Attribute,
+ mut f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>,
+) -> PResult<'a, T> {
+ let mut parser = Parser::new(
+ sess,
+ attr.tokens.clone(),
+ None,
+ false,
+ false,
+ Some("attribute"),
+ );
+ let result = f(&mut parser)?;
+ if parser.token != token::Eof {
+ parser.unexpected()?;
+ }
+ Ok(result)
+}
+
// 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).
}
/// Parse a list of paths inside `#[derive(path_0, ..., path_n)]`.
-
crate fn parse_derive_paths(&mut self) -> PResult<'a, Vec<Path>> {
+
pub 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)) {
+++ /dev/null
-use syntax::{ast, attr, visit};
-use syntax::symbol::{sym, Symbol};
-use syntax_pos::Span;
-
-#[derive(Clone, Copy)]
-pub enum AllocatorKind {
- Global,
- DefaultLib,
- DefaultExe,
-}
-
-impl AllocatorKind {
- pub fn fn_name(&self, base: &str) -> String {
- match *self {
- AllocatorKind::Global => format!("__rg_{}", base),
- AllocatorKind::DefaultLib => format!("__rdl_{}", base),
- AllocatorKind::DefaultExe => format!("__rde_{}", base),
- }
- }
-}
-
-pub enum AllocatorTy {
- Layout,
- Ptr,
- ResultPtr,
- Unit,
- Usize,
-}
-
-pub struct AllocatorMethod {
- pub name: &'static str,
- pub inputs: &'static [AllocatorTy],
- pub output: AllocatorTy,
-}
-
-pub static ALLOCATOR_METHODS: &[AllocatorMethod] = &[
- AllocatorMethod {
- name: "alloc",
- inputs: &[AllocatorTy::Layout],
- output: AllocatorTy::ResultPtr,
- },
- AllocatorMethod {
- name: "dealloc",
- inputs: &[AllocatorTy::Ptr, AllocatorTy::Layout],
- output: AllocatorTy::Unit,
- },
- AllocatorMethod {
- name: "realloc",
- inputs: &[AllocatorTy::Ptr, AllocatorTy::Layout, AllocatorTy::Usize],
- output: AllocatorTy::ResultPtr,
- },
- AllocatorMethod {
- name: "alloc_zeroed",
- inputs: &[AllocatorTy::Layout],
- output: AllocatorTy::ResultPtr,
- },
-];
-
-pub fn global_allocator_spans(krate: &ast::Crate) -> Vec<Span> {
- struct Finder { name: Symbol, spans: Vec<Span> }
- impl<'ast> visit::Visitor<'ast> for Finder {
- fn visit_item(&mut self, item: &'ast ast::Item) {
- if item.ident.name == self.name &&
- attr::contains_name(&item.attrs, sym::rustc_std_internal_symbol) {
- self.spans.push(item.span);
- }
- visit::walk_item(self, item)
- }
- }
-
- let name = Symbol::intern(&AllocatorKind::Global.fn_name("alloc"));
- let mut f = Finder { name, spans: Vec::new() };
- visit::walk_crate(&mut f, krate);
- f.spans
-}
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::{ThinVec, MACRO_ARGUMENTS};
use syntax::tokenstream::{self, TokenStream};
use syntax::visit::Visitor;
+crate use syntax::expand::SpecialDerives;
use errors::{DiagnosticBuilder, DiagnosticId};
use smallvec::{smallvec, SmallVec};
use syntax_pos::{FileName, Span, MultiSpan, DUMMY_SP};
-use syntax_pos::hygiene::{AstPass, ExpnData, ExpnKind};
+use syntax_pos::hygiene::{AstPass, ExpnId, ExpnData, ExpnKind};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sync::{self, Lrc};
use std::rc::Rc;
use std::default::Default;
-pub use syntax_pos::hygiene::MacroKind;
+crate use syntax_pos::hygiene::MacroKind;
#[derive(Debug,Clone)]
pub enum Annotatable {
/// Error type that denotes indeterminacy.
pub struct Indeterminate;
-bitflags::bitflags! {
- /// Built-in derives that need some extra tracking beyond the usual macro functionality.
- #[derive(Default)]
- pub struct SpecialDerives: u8 {
- const PARTIAL_EQ = 1 << 0;
- const EQ = 1 << 1;
- const COPY = 1 << 2;
- }
-}
-
pub trait Resolver {
fn next_node_id(&mut self) -> NodeId;
mod placeholders;
mod proc_macro_server;
-pub use syntax_pos::hygiene;
+crate use syntax_pos::hygiene;
pub use mbe::macro_rules::compile_declarative_macro;
-pub mod allocator;
pub mod base;
pub mod build;
pub mod expand;
fn visit_mac(&mut self, _mac: &Mac) {}
}
-pub fn is_proc_macro_attr(attr: &Attribute) -> bool {
- [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
- .iter().any(|kind| attr.check_name(*kind))
-}
-
crate fn collect_derives(cx: &mut ExtCtxt<'_>, attrs: &mut Vec<ast::Attribute>) -> Vec<ast::Path> {
let mut result = Vec::new();
attrs.retain(|attr| {
return false;
}
- match attr.parse_derive_paths(cx.parse_sess) {
+ let parse_derive_paths = |attr: &ast::Attribute| {
+ if attr.tokens.is_empty() {
+ return Ok(Vec::new());
+ }
+ parse::parse_in_attr(cx.parse_sess, attr, |p| p.parse_derive_paths())
+ };
+
+ match parse_derive_paths(attr) {
Ok(traits) => {
result.extend(traits);
true
use crate::deriving::generic::ty::*;
use syntax::ast::{self, Expr, GenericArg, Generics, ItemKind, MetaItem, VariantData};
-use syntax_expand::base::{Annotatable, ExtCtxt, SpecialDerives};
+use syntax::expand::SpecialDerives;
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P;
use syntax::symbol::{kw, sym, Symbol};
use syntax_pos::Span;
use crate::deriving::generic::ty::*;
use syntax::ast::{self, Ident, Expr, MetaItem, GenericArg};
-use syntax_expand::base::{Annotatable, ExtCtxt, SpecialDerives};
+use syntax::expand::SpecialDerives;
use syntax::ptr::P;
use syntax::symbol::{sym, Symbol};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax_pos::Span;
pub fn expand_deriving_eq(cx: &mut ExtCtxt<'_>,
use crate::deriving::generic::ty::*;
use syntax::ast::{BinOpKind, Expr, MetaItem};
-use syntax_expand::base::{Annotatable, ExtCtxt, SpecialDerives};
+use syntax::expand::SpecialDerives;
use syntax::ptr::P;
use syntax::symbol::sym;
-use syntax_pos::{self, Span};
+use syntax_expand::base::{Annotatable, ExtCtxt};
+use syntax_pos::Span;
pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>,
span: Span,
use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind};
use syntax::ast::{VariantData, GenericParamKind, GenericArg};
use syntax::attr;
+use syntax::expand::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 syntax_expand::base::{Annotatable, ExtCtxt};
+use syntax_pos::Span;
use ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty};
use syntax::ast::{ItemKind, Mutability, Stmt, Ty, TyKind, Unsafety};
use syntax::ast::{self, Param, Attribute, Expr, FnHeader, Generics, Ident};
-use syntax_expand::allocator::{AllocatorKind, AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS};
-use syntax_expand::base::{Annotatable, ExtCtxt};
+use syntax::expand::allocator::{AllocatorKind, AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS};
use syntax::ptr::P;
use syntax::symbol::{kw, sym, Symbol};
+use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax_pos::Span;
pub fn expand(
use smallvec::smallvec;
use syntax::ast::{self, Ident};
use syntax::attr;
+use syntax::expand::is_proc_macro_attr;
use syntax::print::pprust;
use syntax::ptr::P;
use syntax::sess::ParseSess;
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;
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;
+use syntax_pos::hygiene::AstPass;
pub fn inject(
mut krate: ast::Crate,
projects / rust.git / commitdiff