"rustc 0.0.0",
"rustc_data_structures 0.0.0",
"rustc_incremental 0.0.0",
+ "rustc_metadata_utils 0.0.0",
"rustc_mir 0.0.0",
"rustc_target 0.0.0",
"syntax 0.0.0",
"rustc 0.0.0",
"rustc_data_structures 0.0.0",
"rustc_errors 0.0.0",
+ "rustc_metadata_utils 0.0.0",
"rustc_target 0.0.0",
"serialize 0.0.0",
"syntax 0.0.0",
"syntax_pos 0.0.0",
]
+[[package]]
+name = "rustc_metadata_utils"
+version = "0.0.0"
+dependencies = [
+ "rustc 0.0.0",
+ "syntax 0.0.0",
+ "syntax_pos 0.0.0",
+]
+
[[package]]
name = "rustc_mir"
version = "0.0.0"
"rustc 0.0.0",
"rustc_data_structures 0.0.0",
"rustc_errors 0.0.0",
+ "rustc_metadata 0.0.0",
"syntax 0.0.0",
"syntax_pos 0.0.0",
]
//! are *mostly* used as a part of that interface, but these should
//! probably get a better home if someone can find one.
-use hir::def;
use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use hir::map as hir_map;
-use hir::map::definitions::{Definitions, DefKey, DefPathTable};
+use hir::map::definitions::{DefKey, DefPathTable};
use hir::svh::Svh;
use ty::{self, TyCtxt};
use session::{Session, CrateDisambiguator};
use std::any::Any;
use std::path::{Path, PathBuf};
use syntax::ast;
-use syntax::edition::Edition;
-use syntax::ext::base::SyntaxExtension;
use syntax::symbol::Symbol;
use syntax_pos::Span;
use rustc_target::spec::Target;
pub def_id: DefId,
}
-pub enum LoadedMacro {
- MacroDef(ast::Item),
- ProcMacro(Lrc<SyntaxExtension>),
-}
-
#[derive(Copy, Clone, Debug)]
pub struct ExternCrate {
pub src: ExternCrateSource,
pub trait CrateStore {
fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<dyn Any>;
- // access to the metadata loader
- fn metadata_loader(&self) -> &dyn MetadataLoader;
-
// resolve
fn def_key(&self, def: DefId) -> DefKey;
fn def_path(&self, def: DefId) -> hir_map::DefPath;
fn def_path_table(&self, cnum: CrateNum) -> Lrc<DefPathTable>;
// "queries" used in resolve that aren't tracked for incremental compilation
- fn visibility_untracked(&self, def: DefId) -> ty::Visibility;
- fn export_macros_untracked(&self, cnum: CrateNum);
- fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind;
fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol;
fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator;
fn crate_hash_untracked(&self, cnum: CrateNum) -> Svh;
- fn crate_edition_untracked(&self, cnum: CrateNum) -> Edition;
- fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name>;
- fn item_children_untracked(&self, did: DefId, sess: &Session) -> Vec<def::Export>;
- fn load_macro_untracked(&self, did: DefId, sess: &Session) -> LoadedMacro;
fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum>;
fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics;
- fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem;
fn postorder_cnums_untracked(&self) -> Vec<CrateNum>;
// This is basically a 1-based range of ints, which is a little
pub type CrateStoreDyn = dyn CrateStore + sync::Sync;
-// FIXME: find a better place for this?
-pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
- let mut err_count = 0;
- {
- let mut say = |s: &str| {
- match (sp, sess) {
- (_, None) => bug!("{}", s),
- (Some(sp), Some(sess)) => sess.span_err(sp, s),
- (None, Some(sess)) => sess.err(s),
- }
- err_count += 1;
- };
- if s.is_empty() {
- say("crate name must not be empty");
- }
- for c in s.chars() {
- if c.is_alphanumeric() { continue }
- if c == '_' { continue }
- say(&format!("invalid character `{}` in crate name: `{}`", c, s));
- }
- }
-
- if err_count > 0 {
- sess.unwrap().abort_if_errors();
- }
-}
-
-/// A dummy crate store that does not support any non-local crates,
-/// for test purposes.
-pub struct DummyCrateStore;
-
-#[allow(unused_variables)]
-impl CrateStore for DummyCrateStore {
- fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<dyn Any>
- { bug!("crate_data_as_rc_any") }
- // item info
- fn visibility_untracked(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
- fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics
- { bug!("item_generics_cloned") }
-
- // trait/impl-item info
- fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem
- { bug!("associated_item_cloned") }
-
- // crate metadata
- fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind { bug!("is_explicitly_linked") }
- fn export_macros_untracked(&self, cnum: CrateNum) { bug!("export_macros") }
- fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol { bug!("crate_name") }
- fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator {
- bug!("crate_disambiguator")
- }
- fn crate_hash_untracked(&self, cnum: CrateNum) -> Svh { bug!("crate_hash") }
- fn crate_edition_untracked(&self, cnum: CrateNum) -> Edition { bug!("crate_edition_untracked") }
-
- // resolve
- fn def_key(&self, def: DefId) -> DefKey { bug!("def_key") }
- fn def_path(&self, def: DefId) -> hir_map::DefPath {
- bug!("relative_def_path")
- }
- fn def_path_hash(&self, def: DefId) -> hir_map::DefPathHash {
- bug!("def_path_hash")
- }
- fn def_path_table(&self, cnum: CrateNum) -> Lrc<DefPathTable> {
- bug!("def_path_table")
- }
- fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name> {
- bug!("struct_field_names")
- }
- fn item_children_untracked(&self, did: DefId, sess: &Session) -> Vec<def::Export> {
- bug!("item_children")
- }
- fn load_macro_untracked(&self, did: DefId, sess: &Session) -> LoadedMacro { bug!("load_macro") }
-
- fn crates_untracked(&self) -> Vec<CrateNum> { vec![] }
-
- // utility functions
- fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum> { None }
- fn encode_metadata<'a, 'tcx>(&self,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- link_meta: &LinkMeta)
- -> EncodedMetadata {
- bug!("encode_metadata")
- }
- fn metadata_encoding_version(&self) -> &[u8] { bug!("metadata_encoding_version") }
- fn postorder_cnums_untracked(&self) -> Vec<CrateNum> { bug!("postorder_cnums_untracked") }
-
- // access to the metadata loader
- fn metadata_loader(&self) -> &dyn MetadataLoader { bug!("metadata_loader") }
-}
-
-pub trait CrateLoader {
- fn process_extern_crate(&mut self, item: &ast::Item, defs: &Definitions) -> CrateNum;
-
- fn process_path_extern(
- &mut self,
- name: Symbol,
- span: Span,
- ) -> CrateNum;
-
- fn process_use_extern(
- &mut self,
- name: Symbol,
- span: Span,
- id: ast::NodeId,
- defs: &Definitions,
- ) -> CrateNum;
-
- fn postprocess(&mut self, krate: &ast::Crate);
-}
-
// This method is used when generating the command line to pass through to
// system linker. The linker expects undefined symbols on the left of the
// command line to be defined in libraries on the right, not the other way
rustc_data_structures = { path = "../librustc_data_structures" }
rustc_mir = { path = "../librustc_mir" }
rustc_incremental = { path = "../librustc_incremental" }
+rustc_metadata_utils = { path = "../librustc_metadata_utils" }
extern crate syntax;
extern crate syntax_pos;
#[macro_use] extern crate rustc_data_structures;
+extern crate rustc_metadata_utils;
use rustc::ty::TyCtxt;
use rustc::session::config::{self, OutputFilenames, Input, OutputType};
use rustc::session::Session;
-use rustc::middle::cstore::{self, LinkMeta};
+use rustc::middle::cstore::LinkMeta;
use rustc::hir::svh::Svh;
use std::path::{Path, PathBuf};
use syntax::{ast, attr};
use syntax_pos::Span;
+use rustc_metadata_utils::validate_crate_name;
pub fn out_filename(sess: &Session,
crate_type: config::CrateType,
attrs: &[ast::Attribute],
input: &Input) -> String {
let validate = |s: String, span: Option<Span>| {
- cstore::validate_crate_name(sess, &s, span);
+ validate_crate_name(sess, &s, span);
s
};
use rustc::session::search_paths::PathKind;
use rustc::lint;
use rustc::middle::{self, reachable, resolve_lifetime, stability};
-use rustc::middle::cstore::CrateStoreDyn;
use rustc::middle::privacy::AccessLevels;
use rustc::ty::{self, AllArenas, Resolutions, TyCtxt};
use rustc::traits;
codegen_backend: &dyn (::CodegenBackend),
matches: &::getopts::Matches,
sess: &Session,
- cstore: &dyn (::CrateStore),
+ cstore: &CStore,
input: &Input,
odir: &Option<PathBuf>,
ofile: &Option<PathBuf>,
pub hir_forest: hir_map::Forest,
}
-pub struct InnerExpansionResult<'a> {
+pub struct InnerExpansionResult<'a, 'b: 'a> {
pub expanded_crate: ast::Crate,
- pub resolver: Resolver<'a>,
+ pub resolver: Resolver<'a, 'b>,
pub hir_forest: hir_map::Forest,
}
/// Same as phase_2_configure_and_expand, but doesn't let you keep the resolver
/// around
-pub fn phase_2_configure_and_expand_inner<'a, F>(
+pub fn phase_2_configure_and_expand_inner<'a, 'b: 'a, F>(
sess: &'a Session,
cstore: &'a CStore,
mut krate: ast::Crate,
addl_plugins: Option<Vec<String>>,
make_glob_map: MakeGlobMap,
resolver_arenas: &'a ResolverArenas<'a>,
- crate_loader: &'a mut CrateLoader,
+ crate_loader: &'a mut CrateLoader<'b>,
after_expand: F,
-) -> Result<InnerExpansionResult<'a>, CompileIncomplete>
+) -> Result<InnerExpansionResult<'a, 'b>, CompileIncomplete>
where
F: FnOnce(&ast::Crate) -> CompileResult,
{
codegen_backend: &dyn CodegenBackend,
control: &CompileController,
sess: &'tcx Session,
- cstore: &'tcx CrateStoreDyn,
+ cstore: &'tcx CStore,
hir_map: hir_map::Map<'tcx>,
mut analysis: ty::CrateAnalysis,
resolutions: Resolutions,
use rustc::session::{early_error, early_warn};
use rustc::lint::Lint;
use rustc::lint;
-use rustc::middle::cstore::CrateStore;
use rustc_metadata::locator;
use rustc_metadata::cstore::CStore;
use rustc_metadata::dynamic_lib::DynamicLibrary;
_: &dyn CodegenBackend,
_: &getopts::Matches,
_: &Session,
- _: &dyn CrateStore,
+ _: &CStore,
_: &Input,
_: &Option<PathBuf>,
_: &Option<PathBuf>)
codegen_backend: &dyn CodegenBackend,
matches: &getopts::Matches,
sess: &Session,
- cstore: &dyn CrateStore,
+ cstore: &CStore,
input: &Input,
odir: &Option<PathBuf>,
ofile: &Option<PathBuf>)
impl RustcDefaultCalls {
pub fn list_metadata(sess: &Session,
- cstore: &dyn CrateStore,
+ cstore: &CStore,
matches: &getopts::Matches,
input: &Input)
-> Compilation {
let mut v = Vec::new();
locator::list_file_metadata(&sess.target.target,
path,
- cstore.metadata_loader(),
+ &*cstore.metadata_loader,
&mut v)
.unwrap();
println!("{}", String::from_utf8(v).unwrap());
use rustc::ty::{self, TyCtxt, Resolutions, AllArenas};
use rustc::cfg;
use rustc::cfg::graphviz::LabelledCFG;
-use rustc::middle::cstore::CrateStoreDyn;
use rustc::session::Session;
use rustc::session::config::{Input, OutputFilenames};
use rustc_borrowck as borrowck;
use rustc_borrowck::graphviz as borrowck_dot;
+use rustc_metadata::cstore::CStore;
use rustc_mir::util::{write_mir_pretty, write_mir_graphviz};
}
fn call_with_pp_support_hir<'tcx, A, F>(&self,
sess: &'tcx Session,
- cstore: &'tcx CrateStoreDyn,
+ cstore: &'tcx CStore,
hir_map: &hir_map::Map<'tcx>,
analysis: &ty::CrateAnalysis,
resolutions: &Resolutions,
}
pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session,
- cstore: &'tcx CrateStoreDyn,
+ cstore: &'tcx CStore,
hir_map: &hir_map::Map<'tcx>,
analysis: &ty::CrateAnalysis,
resolutions: &Resolutions,
// with a different callback than the standard driver, so that isn't easy.
// Instead, we call that function ourselves.
fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session,
- cstore: &'a CrateStoreDyn,
+ cstore: &'a CStore,
hir_map: &hir_map::Map<'tcx>,
analysis: &ty::CrateAnalysis,
resolutions: &Resolutions,
syntax = { path = "../libsyntax" }
syntax_ext = { path = "../libsyntax_ext" }
syntax_pos = { path = "../libsyntax_pos" }
+rustc_metadata_utils = { path = "../librustc_metadata_utils" }
use rustc::session::config::{Sanitizer, self};
use rustc_target::spec::{PanicStrategy, TargetTriple};
use rustc::session::search_paths::PathKind;
-use rustc::middle;
-use rustc::middle::cstore::{validate_crate_name, ExternCrate, ExternCrateSource};
+use rustc::middle::cstore::{ExternCrate, ExternCrateSource};
use rustc::util::common::record_time;
use rustc::util::nodemap::FxHashSet;
use rustc::hir::map::Definitions;
+use rustc_metadata_utils::validate_crate_name;
+
use std::ops::Deref;
use std::path::PathBuf;
use std::{cmp, fs};
}
}
-impl<'a> middle::cstore::CrateLoader for CrateLoader<'a> {
- fn postprocess(&mut self, krate: &ast::Crate) {
+impl<'a> CrateLoader<'a> {
+ pub fn postprocess(&mut self, krate: &ast::Crate) {
// inject the sanitizer runtime before the allocator runtime because all
// sanitizers force the use of the `alloc_system` allocator
self.inject_sanitizer_runtime();
}
}
- fn process_extern_crate(&mut self, item: &ast::Item, definitions: &Definitions) -> CrateNum {
+ pub fn process_extern_crate(
+ &mut self, item: &ast::Item, definitions: &Definitions,
+ ) -> CrateNum {
match item.node {
ast::ItemKind::ExternCrate(orig_name) => {
debug!("resolving extern crate stmt. ident: {} orig_name: {:?}",
}
}
- fn process_path_extern(
+ pub fn process_path_extern(
&mut self,
name: Symbol,
span: Span,
cnum
}
- fn process_use_extern(
+ pub fn process_use_extern(
&mut self,
name: Symbol,
span: Span,
pub metadata_loader: Box<dyn MetadataLoader + Sync>,
}
+pub enum LoadedMacro {
+ MacroDef(ast::Item),
+ ProcMacro(Lrc<SyntaxExtension>),
+}
+
impl CStore {
pub fn new(metadata_loader: Box<dyn MetadataLoader + Sync>) -> CStore {
CStore {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use cstore;
+use cstore::{self, LoadedMacro};
use encoder;
use link_args;
use native_libs;
use rustc::ty::query::QueryConfig;
use rustc::middle::cstore::{CrateStore, DepKind,
- MetadataLoader, LinkMeta,
- LoadedMacro, EncodedMetadata, NativeLibraryKind};
+ LinkMeta,
+ EncodedMetadata, NativeLibraryKind};
use rustc::middle::exported_symbols::ExportedSymbol;
use rustc::middle::stability::DeprecationEntry;
use rustc::hir::def;
};
}
-impl CrateStore for cstore::CStore {
- fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<dyn Any> {
- self.get_crate_data(krate)
- }
-
- fn metadata_loader(&self) -> &dyn MetadataLoader {
- &*self.metadata_loader
- }
-
- fn visibility_untracked(&self, def: DefId) -> ty::Visibility {
- self.get_crate_data(def.krate).get_visibility(def.index)
- }
-
- fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics {
- self.get_crate_data(def.krate).get_generics(def.index, sess)
- }
-
- fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem
- {
- self.get_crate_data(def.krate).get_associated_item(def.index)
- }
-
- fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind
- {
- let data = self.get_crate_data(cnum);
- let r = *data.dep_kind.lock();
- r
- }
-
- fn export_macros_untracked(&self, cnum: CrateNum) {
+impl cstore::CStore {
+ pub fn export_macros_untracked(&self, cnum: CrateNum) {
let data = self.get_crate_data(cnum);
let mut dep_kind = data.dep_kind.lock();
if *dep_kind == DepKind::UnexportedMacrosOnly {
}
}
- fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol
- {
- self.get_crate_data(cnum).name
- }
-
- fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator
- {
- self.get_crate_data(cnum).root.disambiguator
- }
-
- fn crate_hash_untracked(&self, cnum: CrateNum) -> hir::svh::Svh
- {
- self.get_crate_data(cnum).root.hash
+ pub fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind {
+ let data = self.get_crate_data(cnum);
+ let r = *data.dep_kind.lock();
+ r
}
- fn crate_edition_untracked(&self, cnum: CrateNum) -> Edition
- {
+ pub fn crate_edition_untracked(&self, cnum: CrateNum) -> Edition {
self.get_crate_data(cnum).root.edition
}
- /// Returns the `DefKey` for a given `DefId`. This indicates the
- /// parent `DefId` as well as some idea of what kind of data the
- /// `DefId` refers to.
- fn def_key(&self, def: DefId) -> DefKey {
- // Note: loading the def-key (or def-path) for a def-id is not
- // a *read* of its metadata. This is because the def-id is
- // really just an interned shorthand for a def-path, which is the
- // canonical name for an item.
- //
- // self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).def_key(def.index)
- }
-
- fn def_path(&self, def: DefId) -> DefPath {
- // See `Note` above in `def_key()` for why this read is
- // commented out:
- //
- // self.dep_graph.read(DepNode::MetaData(def));
- self.get_crate_data(def.krate).def_path(def.index)
- }
-
- fn def_path_hash(&self, def: DefId) -> DefPathHash {
- self.get_crate_data(def.krate).def_path_hash(def.index)
- }
-
- fn def_path_table(&self, cnum: CrateNum) -> Lrc<DefPathTable> {
- self.get_crate_data(cnum).def_path_table.clone()
- }
-
- fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name>
- {
+ pub fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name> {
self.get_crate_data(def.krate).get_struct_field_names(def.index)
}
- fn item_children_untracked(&self, def_id: DefId, sess: &Session) -> Vec<def::Export>
- {
+ pub fn item_children_untracked(&self, def_id: DefId, sess: &Session) -> Vec<def::Export> {
let mut result = vec![];
self.get_crate_data(def_id.krate)
.each_child_of_item(def_id.index, |child| result.push(child), sess);
result
}
- fn load_macro_untracked(&self, id: DefId, sess: &Session) -> LoadedMacro {
+ pub fn load_macro_untracked(&self, id: DefId, sess: &Session) -> LoadedMacro {
let data = self.get_crate_data(id.krate);
if let Some(ref proc_macros) = data.proc_macros {
return LoadedMacro::ProcMacro(proc_macros[id.index.to_proc_macro_index()].1.clone());
})
}
+ pub fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem {
+ self.get_crate_data(def.krate).get_associated_item(def.index)
+ }
+}
+
+impl CrateStore for cstore::CStore {
+ fn crate_data_as_rc_any(&self, krate: CrateNum) -> Lrc<dyn Any> {
+ self.get_crate_data(krate)
+ }
+
+ fn item_generics_cloned_untracked(&self, def: DefId, sess: &Session) -> ty::Generics {
+ self.get_crate_data(def.krate).get_generics(def.index, sess)
+ }
+
+ fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol
+ {
+ self.get_crate_data(cnum).name
+ }
+
+ fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> CrateDisambiguator
+ {
+ self.get_crate_data(cnum).root.disambiguator
+ }
+
+ fn crate_hash_untracked(&self, cnum: CrateNum) -> hir::svh::Svh
+ {
+ self.get_crate_data(cnum).root.hash
+ }
+
+ /// Returns the `DefKey` for a given `DefId`. This indicates the
+ /// parent `DefId` as well as some idea of what kind of data the
+ /// `DefId` refers to.
+ fn def_key(&self, def: DefId) -> DefKey {
+ // Note: loading the def-key (or def-path) for a def-id is not
+ // a *read* of its metadata. This is because the def-id is
+ // really just an interned shorthand for a def-path, which is the
+ // canonical name for an item.
+ //
+ // self.dep_graph.read(DepNode::MetaData(def));
+ self.get_crate_data(def.krate).def_key(def.index)
+ }
+
+ fn def_path(&self, def: DefId) -> DefPath {
+ // See `Note` above in `def_key()` for why this read is
+ // commented out:
+ //
+ // self.dep_graph.read(DepNode::MetaData(def));
+ self.get_crate_data(def.krate).def_path(def.index)
+ }
+
+ fn def_path_hash(&self, def: DefId) -> DefPathHash {
+ self.get_crate_data(def.krate).def_path_hash(def.index)
+ }
+
+ fn def_path_table(&self, cnum: CrateNum) -> Lrc<DefPathTable> {
+ self.get_crate_data(cnum).def_path_table.clone()
+ }
+
fn crates_untracked(&self) -> Vec<CrateNum>
{
let mut result = vec![];
extern crate rustc_errors as errors;
extern crate syntax_ext;
extern crate proc_macro;
+extern crate rustc_metadata_utils;
#[macro_use]
extern crate rustc;
--- /dev/null
+[package]
+authors = ["The Rust Project Developers"]
+name = "rustc_metadata_utils"
+version = "0.0.0"
+
+[lib]
+name = "rustc_metadata_utils"
+path = "lib.rs"
+crate-type = ["dylib"]
+
+[dependencies]
+rustc = { path = "../librustc" }
+syntax = { path = "../libsyntax" }
+syntax_pos = { path = "../libsyntax_pos" }
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate rustc;
+extern crate syntax_pos;
+
+use rustc::session::Session;
+use syntax_pos::Span;
+
+pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
+ let mut err_count = 0;
+ {
+ let mut say = |s: &str| {
+ match (sp, sess) {
+ (_, None) => bug!("{}", s),
+ (Some(sp), Some(sess)) => sess.span_err(sp, s),
+ (None, Some(sess)) => sess.err(s),
+ }
+ err_count += 1;
+ };
+ if s.is_empty() {
+ say("crate name must not be empty");
+ }
+ for c in s.chars() {
+ if c.is_alphanumeric() { continue }
+ if c == '_' { continue }
+ say(&format!("invalid character `{}` in crate name: `{}`", c, s));
+ }
+ }
+
+ if err_count > 0 {
+ sess.unwrap().abort_if_errors();
+ }
+}
use rustc::infer::InferCtxt;
use rustc::mir::Mir;
use rustc::ty::subst::{Substs, UnpackedKind};
-use rustc::ty::{self, RegionVid, Ty, TyCtxt};
+use rustc::ty::{self, RegionKind, RegionVid, Ty, TyCtxt};
use rustc::util::ppaux::with_highlight_region;
use rustc_errors::DiagnosticBuilder;
-use syntax::ast::Name;
+use syntax::ast::{Name, DUMMY_NODE_ID};
use syntax::symbol::keywords;
use syntax_pos::symbol::InternedString;
diag: &mut DiagnosticBuilder<'_>,
) -> Option<InternedString> {
let error_region = self.to_error_region(fr)?;
+
debug!("give_region_a_name: error_region = {:?}", error_region);
match error_region {
- ty::ReEarlyBound(ebr) => Some(ebr.name),
+ ty::ReEarlyBound(ebr) => {
+ self.highlight_named_span(tcx, error_region, &ebr.name, diag);
+ Some(ebr.name)
+ },
ty::ReStatic => Some(keywords::StaticLifetime.name().as_interned_str()),
ty::ReFree(free_region) => match free_region.bound_region {
- ty::BoundRegion::BrNamed(_, name) => Some(name),
+ ty::BoundRegion::BrNamed(_, name) => {
+ self.highlight_named_span(tcx, error_region, &name, diag);
+ Some(name)
+ },
ty::BoundRegion::BrEnv => {
let closure_span = tcx.hir.span_if_local(mir_def_id).unwrap();
}
}
+ /// Highlight a named span to provide context for error messages that
+ /// mention that span, for example:
+ ///
+ /// ```
+ /// |
+ /// | fn two_regions<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ /// | -- -- lifetime `'b` defined here
+ /// | |
+ /// | lifetime `'a` defined here
+ /// |
+ /// | with_signature(cell, t, |cell, t| require(cell, t));
+ /// | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must
+ /// | outlive `'a`
+ /// ```
+ fn highlight_named_span(
+ &self,
+ tcx: TyCtxt<'_, '_, 'tcx>,
+ error_region: &RegionKind,
+ name: &InternedString,
+ diag: &mut DiagnosticBuilder<'_>,
+ ) {
+ let cm = tcx.sess.codemap();
+
+ let scope = error_region.free_region_binding_scope(tcx);
+ let node = tcx.hir.as_local_node_id(scope).unwrap_or(DUMMY_NODE_ID);
+
+ let mut sp = cm.def_span(tcx.hir.span(node));
+ if let Some(param) = tcx.hir.get_generics(scope).and_then(|generics| {
+ generics.get_named(name)
+ }) {
+ sp = param.span;
+ }
+
+ diag.span_label(
+ sp,
+ format!("lifetime `{}` defined here", name),
+ );
+ }
+
/// Find an argument that contains `fr` and label it with a fully
/// elaborated type, returning something like `'1`. Result looks
/// like:
rustc_errors = { path = "../librustc_errors" }
syntax_pos = { path = "../libsyntax_pos" }
rustc_data_structures = { path = "../librustc_data_structures" }
+rustc_metadata = { path = "../librustc_metadata" }
use Namespace::{self, TypeNS, ValueNS, MacroNS};
use {resolve_error, resolve_struct_error, ResolutionError};
-use rustc::middle::cstore::LoadedMacro;
use rustc::hir::def::*;
use rustc::hir::def_id::{BUILTIN_MACROS_CRATE, CRATE_DEF_INDEX, LOCAL_CRATE, DefId};
use rustc::ty;
+use rustc::middle::cstore::CrateStore;
+use rustc_metadata::cstore::LoadedMacro;
use std::cell::Cell;
use rustc_data_structures::sync::Lrc;
imports: Vec<(Name, Span)>,
}
-impl<'a> Resolver<'a> {
+impl<'a, 'cl> Resolver<'a, 'cl> {
/// Defines `name` in namespace `ns` of module `parent` to be `def` if it is not yet defined;
/// otherwise, reports an error.
pub fn define<T>(&mut self, parent: Module<'a>, ident: Ident, ns: Namespace, def: T)
}
}
-pub struct BuildReducedGraphVisitor<'a, 'b: 'a> {
- pub resolver: &'a mut Resolver<'b>,
+pub struct BuildReducedGraphVisitor<'a, 'b: 'a, 'c: 'b> {
+ pub resolver: &'a mut Resolver<'b, 'c>,
pub legacy_scope: LegacyScope<'b>,
pub expansion: Mark,
}
-impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
+impl<'a, 'b, 'cl> BuildReducedGraphVisitor<'a, 'b, 'cl> {
fn visit_invoc(&mut self, id: ast::NodeId) -> &'b InvocationData<'b> {
let mark = id.placeholder_to_mark();
self.resolver.current_module.unresolved_invocations.borrow_mut().insert(mark);
}
}
-impl<'a, 'b> Visitor<'a> for BuildReducedGraphVisitor<'a, 'b> {
+impl<'a, 'b, 'cl> Visitor<'a> for BuildReducedGraphVisitor<'a, 'b, 'cl> {
method!(visit_impl_item: ast::ImplItem, ast::ImplItemKind::Macro, walk_impl_item);
method!(visit_expr: ast::Expr, ast::ExprKind::Mac, walk_expr);
method!(visit_pat: ast::Pat, ast::PatKind::Mac, walk_pat);
use syntax_pos::{Span, MultiSpan, DUMMY_SP};
-struct UnusedImportCheckVisitor<'a, 'b: 'a> {
- resolver: &'a mut Resolver<'b>,
+struct UnusedImportCheckVisitor<'a, 'b: 'a, 'd: 'b> {
+ resolver: &'a mut Resolver<'b, 'd>,
/// All the (so far) unused imports, grouped path list
unused_imports: NodeMap<NodeMap<Span>>,
base_id: ast::NodeId,
}
// Deref and DerefMut impls allow treating UnusedImportCheckVisitor as Resolver.
-impl<'a, 'b> Deref for UnusedImportCheckVisitor<'a, 'b> {
- type Target = Resolver<'b>;
+impl<'a, 'b, 'd> Deref for UnusedImportCheckVisitor<'a, 'b, 'd> {
+ type Target = Resolver<'b, 'd>;
- fn deref<'c>(&'c self) -> &'c Resolver<'b> {
+ fn deref<'c>(&'c self) -> &'c Resolver<'b, 'd> {
&*self.resolver
}
}
-impl<'a, 'b> DerefMut for UnusedImportCheckVisitor<'a, 'b> {
- fn deref_mut<'c>(&'c mut self) -> &'c mut Resolver<'b> {
+impl<'a, 'b, 'd> DerefMut for UnusedImportCheckVisitor<'a, 'b, 'd> {
+ fn deref_mut<'c>(&'c mut self) -> &'c mut Resolver<'b, 'd> {
&mut *self.resolver
}
}
-impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
+impl<'a, 'b, 'd> UnusedImportCheckVisitor<'a, 'b, 'd> {
// We have information about whether `use` (import) directives are actually
// used now. If an import is not used at all, we signal a lint error.
fn check_import(&mut self, item_id: ast::NodeId, id: ast::NodeId, span: Span) {
}
}
-impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> {
+impl<'a, 'b, 'cl> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b, 'cl> {
fn visit_item(&mut self, item: &'a ast::Item) {
self.item_span = item.span;
#[macro_use]
extern crate rustc;
extern crate rustc_data_structures;
+extern crate rustc_metadata;
pub use rustc::hir::def::{Namespace, PerNS};
use rustc::hir::map::{Definitions, DefCollector};
use rustc::hir::{self, PrimTy, TyBool, TyChar, TyFloat, TyInt, TyUint, TyStr};
-use rustc::middle::cstore::{CrateStore, CrateLoader};
+use rustc::middle::cstore::CrateStore;
use rustc::session::Session;
use rustc::lint;
use rustc::hir::def::*;
use rustc::hir::{Freevar, FreevarMap, TraitCandidate, TraitMap, GlobMap};
use rustc::util::nodemap::{NodeMap, NodeSet, FxHashMap, FxHashSet, DefIdMap};
+use rustc_metadata::creader::CrateLoader;
+use rustc_metadata::cstore::CStore;
+
use syntax::codemap::CodeMap;
use syntax::ext::hygiene::{Mark, Transparency, SyntaxContext};
use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
}
/// This thing walks the whole crate in DFS manner, visiting each item, resolving names as it goes.
-impl<'a, 'tcx> Visitor<'tcx> for Resolver<'a> {
+impl<'a, 'tcx, 'cl> Visitor<'tcx> for Resolver<'a, 'cl> {
fn visit_item(&mut self, item: &'tcx Item) {
self.resolve_item(item);
}
}
}
- fn get_macro(&self, resolver: &mut Resolver<'a>) -> Lrc<SyntaxExtension> {
+ fn get_macro<'b: 'a>(&self, resolver: &mut Resolver<'a, 'b>) -> Lrc<SyntaxExtension> {
resolver.get_macro(self.def_ignoring_ambiguity())
}
/// The main resolver class.
///
/// This is the visitor that walks the whole crate.
-pub struct Resolver<'a> {
+pub struct Resolver<'a, 'b: 'a> {
session: &'a Session,
- cstore: &'a dyn CrateStore,
+ cstore: &'a CStore,
pub definitions: Definitions,
/// true if `#![feature(use_extern_macros)]`
use_extern_macros: bool,
- crate_loader: &'a mut dyn CrateLoader,
+ crate_loader: &'a mut CrateLoader<'b>,
macro_names: FxHashSet<Ident>,
macro_prelude: FxHashMap<Name, &'a NameBinding<'a>>,
pub all_macros: FxHashMap<Name, Def>,
}
}
-impl<'a, 'b: 'a> ty::DefIdTree for &'a Resolver<'b> {
+impl<'a, 'b: 'a, 'cl: 'b> ty::DefIdTree for &'a Resolver<'b, 'cl> {
fn parent(self, id: DefId) -> Option<DefId> {
match id.krate {
LOCAL_CRATE => self.definitions.def_key(id.index).parent,
/// This interface is used through the AST→HIR step, to embed full paths into the HIR. After that
/// the resolver is no longer needed as all the relevant information is inline.
-impl<'a> hir::lowering::Resolver for Resolver<'a> {
+impl<'a, 'cl> hir::lowering::Resolver for Resolver<'a, 'cl> {
fn resolve_hir_path(&mut self, path: &mut hir::Path, is_value: bool) {
self.resolve_hir_path_cb(path, is_value,
|resolver, span, error| resolve_error(resolver, span, error))
}
}
-impl<'a> Resolver<'a> {
+impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
/// Rustdoc uses this to resolve things in a recoverable way. ResolutionError<'a>
/// isn't something that can be returned because it can't be made to live that long,
/// and also it's a private type. Fortunately rustdoc doesn't need to know the error,
}
}
-impl<'a> Resolver<'a> {
+impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
pub fn new(session: &'a Session,
- cstore: &'a dyn CrateStore,
+ cstore: &'a CStore,
krate: &Crate,
crate_name: &str,
make_glob_map: MakeGlobMap,
- crate_loader: &'a mut dyn CrateLoader,
+ crate_loader: &'a mut CrateLoader<'crateloader>,
arenas: &'a ResolverArenas<'a>)
- -> Resolver<'a> {
+ -> Resolver<'a, 'crateloader> {
let root_def_id = DefId::local(CRATE_DEF_INDEX);
let root_module_kind = ModuleKind::Def(Def::Mod(root_def_id), keywords::Invalid.name());
let graph_root = arenas.alloc_module(ModuleData {
use rustc::hir::def::{Def, Export};
use rustc::hir::map::{self, DefCollector};
use rustc::{ty, lint};
+use rustc::middle::cstore::CrateStore;
use syntax::ast::{self, Name, Ident};
use syntax::attr::{self, HasAttrs};
use syntax::errors::DiagnosticBuilder;
}
}
-impl<'a> base::Resolver for Resolver<'a> {
+impl<'a, 'crateloader: 'a> base::Resolver for Resolver<'a, 'crateloader> {
fn next_node_id(&mut self) -> ast::NodeId {
self.session.next_node_id()
}
}
fn eliminate_crate_var(&mut self, item: P<ast::Item>) -> P<ast::Item> {
- struct EliminateCrateVar<'b, 'a: 'b>(&'b mut Resolver<'a>, Span);
+ struct EliminateCrateVar<'b, 'a: 'b, 'crateloader: 'a>(
+ &'b mut Resolver<'a, 'crateloader>, Span
+ );
- impl<'a, 'b> Folder for EliminateCrateVar<'a, 'b> {
+ impl<'a, 'b, 'crateloader> Folder for EliminateCrateVar<'a, 'b, 'crateloader> {
fn fold_path(&mut self, path: ast::Path) -> ast::Path {
match self.fold_qpath(None, path) {
(None, path) => path,
}
}
-impl<'a> Resolver<'a> {
+impl<'a, 'cl> Resolver<'a, 'cl> {
fn report_proc_macro_stub(&self, span: Span) {
self.session.span_err(span,
"can't use a procedural macro from the same crate that defines it");
}
}
-impl<'a> Resolver<'a> {
+impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
fn resolution(&self, module: Module<'a>, ident: Ident, ns: Namespace)
-> &'a RefCell<NameResolution<'a>> {
*module.resolutions.borrow_mut().entry((ident.modern(), ns))
// If the resolution becomes a success, define it in the module's glob importers.
fn update_resolution<T, F>(&mut self, module: Module<'a>, ident: Ident, ns: Namespace, f: F)
-> T
- where F: FnOnce(&mut Resolver<'a>, &mut NameResolution<'a>) -> T
+ where F: FnOnce(&mut Resolver<'a, 'crateloader>, &mut NameResolution<'a>) -> T
{
// Ensure that `resolution` isn't borrowed when defining in the module's glob importers,
// during which the resolution might end up getting re-defined via a glob cycle.
}
}
-pub struct ImportResolver<'a, 'b: 'a> {
- pub resolver: &'a mut Resolver<'b>,
+pub struct ImportResolver<'a, 'b: 'a, 'c: 'a + 'b> {
+ pub resolver: &'a mut Resolver<'b, 'c>,
}
-impl<'a, 'b: 'a> ::std::ops::Deref for ImportResolver<'a, 'b> {
- type Target = Resolver<'b>;
- fn deref(&self) -> &Resolver<'b> {
+impl<'a, 'b: 'a, 'c: 'a + 'b> ::std::ops::Deref for ImportResolver<'a, 'b, 'c> {
+ type Target = Resolver<'b, 'c>;
+ fn deref(&self) -> &Resolver<'b, 'c> {
self.resolver
}
}
-impl<'a, 'b: 'a> ::std::ops::DerefMut for ImportResolver<'a, 'b> {
- fn deref_mut(&mut self) -> &mut Resolver<'b> {
+impl<'a, 'b: 'a, 'c: 'a + 'b> ::std::ops::DerefMut for ImportResolver<'a, 'b, 'c> {
+ fn deref_mut(&mut self) -> &mut Resolver<'b, 'c> {
self.resolver
}
}
-impl<'a, 'b: 'a> ty::DefIdTree for &'a ImportResolver<'a, 'b> {
+impl<'a, 'b: 'a, 'c: 'a + 'b> ty::DefIdTree for &'a ImportResolver<'a, 'b, 'c> {
fn parent(self, id: DefId) -> Option<DefId> {
self.resolver.parent(id)
}
}
-impl<'a, 'b:'a> ImportResolver<'a, 'b> {
+impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
// Import resolution
//
// This is a fixed-point algorithm. We resolve imports until our efforts
use rustc::ty::{self, ToPredicate, TypeFoldable};
use rustc::ty::subst::Subst;
use rustc::infer::InferOk;
+use rustc::middle::cstore::CrateStore;
use std::fmt::Debug;
use syntax_pos::DUMMY_SP;
use super::*;
-pub struct AutoTraitFinder<'a, 'tcx: 'a, 'rcx: 'a> {
- pub cx: &'a core::DocContext<'a, 'tcx, 'rcx>,
+pub struct AutoTraitFinder<'a, 'tcx: 'a, 'rcx: 'a, 'cstore: 'rcx> {
+ pub cx: &'a core::DocContext<'a, 'tcx, 'rcx, 'cstore>,
pub f: auto::AutoTraitFinder<'a, 'tcx>,
}
-impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
- pub fn new(cx: &'a core::DocContext<'a, 'tcx, 'rcx>) -> Self {
+impl<'a, 'tcx, 'rcx, 'cstore> AutoTraitFinder<'a, 'tcx, 'rcx, 'cstore> {
+ pub fn new(cx: &'a core::DocContext<'a, 'tcx, 'rcx, 'cstore>) -> Self {
let f = auto::AutoTraitFinder::new(&cx.tcx);
AutoTraitFinder { cx, f }
use rustc::hir;
use rustc::hir::def::{Def, CtorKind};
use rustc::hir::def_id::DefId;
-use rustc::middle::cstore::LoadedMacro;
+use rustc_metadata::cstore::LoadedMacro;
use rustc::ty;
use rustc::util::nodemap::FxHashSet;
pub masked_crates: FxHashSet<CrateNum>,
}
-impl<'a, 'tcx, 'rcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx, 'rcx> {
+impl<'a, 'tcx, 'rcx, 'cstore> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx, 'rcx, 'cstore> {
fn clean(&self, cx: &DocContext) -> Crate {
use ::visit_lib::LibEmbargoVisitor;
use rustc::session::{self, config};
use rustc::hir::def_id::{DefId, CrateNum, LOCAL_CRATE};
use rustc::hir::def::Def;
-use rustc::middle::cstore::CrateStore;
use rustc::middle::privacy::AccessLevels;
use rustc::ty::{self, TyCtxt, AllArenas};
use rustc::hir::map as hir_map;
pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>;
-pub struct DocContext<'a, 'tcx: 'a, 'rcx: 'a> {
+pub struct DocContext<'a, 'tcx: 'a, 'rcx: 'a, 'cstore: 'rcx> {
pub tcx: TyCtxt<'a, 'tcx, 'tcx>,
- pub resolver: &'a RefCell<resolve::Resolver<'rcx>>,
+ pub resolver: &'a RefCell<resolve::Resolver<'rcx, 'cstore>>,
/// The stack of module NodeIds up till this point
pub mod_ids: RefCell<Vec<NodeId>>,
pub crate_name: Option<String>,
- pub cstore: Rc<dyn CrateStore>,
+ pub cstore: Rc<CStore>,
pub populated_all_crate_impls: Cell<bool>,
// Note that external items for which `doc(hidden)` applies to are shown as
// non-reachable while local items aren't. This is because we're reusing
pub all_traits: Vec<DefId>,
}
-impl<'a, 'tcx, 'rcx> DocContext<'a, 'tcx, 'rcx> {
+impl<'a, 'tcx, 'rcx, 'cstore> DocContext<'a, 'tcx, 'rcx, 'cstore> {
pub fn sess(&self) -> &session::Session {
&self.tcx.sess
}
// also, is there some reason that this doesn't use the 'visit'
// framework from syntax?
-pub struct RustdocVisitor<'a, 'tcx: 'a, 'rcx: 'a> {
+pub struct RustdocVisitor<'a, 'tcx: 'a, 'rcx: 'a, 'cstore: 'rcx> {
pub module: Module,
pub attrs: hir::HirVec<ast::Attribute>,
- pub cx: &'a core::DocContext<'a, 'tcx, 'rcx>,
+ pub cx: &'a core::DocContext<'a, 'tcx, 'rcx, 'cstore>,
view_item_stack: FxHashSet<ast::NodeId>,
inlining: bool,
/// Is the current module and all of its parents public?
exact_paths: Option<FxHashMap<DefId, Vec<String>>>,
}
-impl<'a, 'tcx, 'rcx> RustdocVisitor<'a, 'tcx, 'rcx> {
- pub fn new(cx: &'a core::DocContext<'a, 'tcx, 'rcx>) -> RustdocVisitor<'a, 'tcx, 'rcx> {
+impl<'a, 'tcx, 'rcx, 'cstore> RustdocVisitor<'a, 'tcx, 'rcx, 'cstore> {
+ pub fn new(
+ cx: &'a core::DocContext<'a, 'tcx, 'rcx, 'cstore>
+ ) -> RustdocVisitor<'a, 'tcx, 'rcx, 'cstore> {
// If the root is re-exported, terminate all recursion.
let mut stack = FxHashSet();
stack.insert(ast::CRATE_NODE_ID);
/// Similar to `librustc_privacy::EmbargoVisitor`, but also takes
/// specific rustdoc annotations into account (i.e. `doc(hidden)`)
-pub struct LibEmbargoVisitor<'a, 'tcx: 'a, 'rcx: 'a> {
- cx: &'a ::core::DocContext<'a, 'tcx, 'rcx>,
+pub struct LibEmbargoVisitor<'a, 'tcx: 'a, 'rcx: 'a, 'cstore: 'rcx> {
+ cx: &'a ::core::DocContext<'a, 'tcx, 'rcx, 'cstore>,
// Accessibility levels for reachable nodes
access_levels: RefMut<'a, AccessLevels<DefId>>,
// Previous accessibility level, None means unreachable
visited_mods: FxHashSet<DefId>,
}
-impl<'a, 'tcx, 'rcx> LibEmbargoVisitor<'a, 'tcx, 'rcx> {
- pub fn new(cx: &'a ::core::DocContext<'a, 'tcx, 'rcx>) -> LibEmbargoVisitor<'a, 'tcx, 'rcx> {
+impl<'a, 'tcx, 'rcx, 'cstore> LibEmbargoVisitor<'a, 'tcx, 'rcx, 'cstore> {
+ pub fn new(
+ cx: &'a ::core::DocContext<'a, 'tcx, 'rcx, 'cstore>
+ ) -> LibEmbargoVisitor<'a, 'tcx, 'rcx, 'cstore> {
LibEmbargoVisitor {
cx,
access_levels: cx.access_levels.borrow_mut(),
extern crate rustc_codegen_utils;
extern crate syntax;
extern crate rustc_errors as errors;
+extern crate rustc_metadata;
-use rustc::middle::cstore::CrateStore;
use rustc::session::Session;
use rustc::session::config::{self, Input};
use rustc_driver::{driver, CompilerCalls, Compilation};
use rustc_codegen_utils::codegen_backend::CodegenBackend;
+use rustc_metadata::cstore::CStore;
use syntax::ast;
use std::path::PathBuf;
_: &CodegenBackend,
_: &getopts::Matches,
_: &Session,
- _: &CrateStore,
+ _: &CStore,
_: &Input,
_: &Option<PathBuf>,
_: &Option<PathBuf>)
error: unsatisfied lifetime constraints
--> $DIR/static-return-lifetime-infered.rs:21:9
|
+LL | fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> {
+ | -- lifetime `'a` defined here
LL | self.x.iter().map(|a| a.0)
| ^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
error: unsatisfied lifetime constraints
--> $DIR/issue-10291.rs:12:5
|
+LL | fn test<'x>(x: &'x isize) {
+ | -- lifetime `'x` defined here
LL | drop::<Box<for<'z> FnMut(&'z isize) -> &'z isize>>(Box::new(|z| {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ requires that `'x` must outlive `'static`
error: unsatisfied lifetime constraints
--> $DIR/issue-52213.rs:13:11
|
+LL | fn transmute_lifetime<'a, 'b, T>(t: &'a (T,)) -> &'b T {
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+LL | match (&t,) { //~ ERROR cannot infer an appropriate lifetime
LL | ((u,),) => u,
| ^ requires that `'a` must outlive `'b`
error: unsatisfied lifetime constraints
--> $DIR/region-lbr-named-does-not-outlive-static.rs:19:5
|
+LL | fn foo<'a>(x: &'a u32) -> &'static u32 {
+ | -- lifetime `'a` defined here
LL | &*x
| ^^^ requires that `'a` must outlive `'static`
error: unsatisfied lifetime constraints
--> $DIR/mir_check_cast_closure.rs:16:28
|
+LL | fn bar<'a, 'b>() -> fn(&'a u32, &'b u32) -> &'a u32 {
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
LL | let g: fn(_, _) -> _ = |_x, y| y;
| ^^^^^^^^^ cast requires that `'b` must outlive `'a`
--> $DIR/mir_check_cast_unsize.rs:17:46
|
LL | fn bar<'a>(x: &'a u32) -> &'static dyn Debug {
- | ______________________________________________^
+ | ________--____________________________________^
+ | | |
+ | | lifetime `'a` defined here
LL | | //~^ ERROR unsatisfied lifetime constraints
LL | | x
LL | | //~^ WARNING not reporting region error due to nll
error: unsatisfied lifetime constraints
--> $DIR/projection-one-region-closure.rs:55:5
|
+LL | fn no_relationships_late<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must outlive `'a`
error: unsatisfied lifetime constraints
--> $DIR/projection-one-region-closure.rs:67:5
|
+LL | fn no_relationships_early<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must outlive `'a`
error: unsatisfied lifetime constraints
--> $DIR/projection-one-region-closure.rs:89:5
|
+LL | fn projection_outlives<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must outlive `'a`
error: unsatisfied lifetime constraints
--> $DIR/projection-one-region-trait-bound-closure.rs:47:5
|
+LL | fn no_relationships_late<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must outlive `'a`
error: unsatisfied lifetime constraints
--> $DIR/projection-one-region-trait-bound-closure.rs:58:5
|
+LL | fn no_relationships_early<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must outlive `'a`
error: unsatisfied lifetime constraints
--> $DIR/projection-one-region-trait-bound-closure.rs:79:5
|
+LL | fn projection_outlives<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must outlive `'a`
error: unsatisfied lifetime constraints
--> $DIR/projection-two-region-trait-bound-closure.rs:108:5
|
+LL | fn two_regions<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- -- lifetime `'b` defined here
+ | |
+ | lifetime `'a` defined here
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ argument requires that `'b` must outlive `'a`
-Subproject commit 8ef759e0273ad97f1acbb1ea9f94322aa2a20147
+Subproject commit dde49f34a8c48981ce337f681f90c1e3b05e05ca
projects / rust.git / commitdiff