Auto merge of #47276 - kennytm:rollup, r=kennytm
Rollup of 10 pull requests - Successful merges: #47210, #47233, #47246, #47254, #47256, #47258, #47259, #47263, #47270, #47272 - Failed merges: #47248
This commit is contained in:
commit
74966b5cb8
45 changed files with 192 additions and 162 deletions
|
@ -83,9 +83,12 @@ pub type Result = result::Result<(), Error>;
|
|||
/// some other means.
|
||||
///
|
||||
/// An important thing to remember is that the type `fmt::Error` should not be
|
||||
/// confused with `std::io::Error` or `std::error::Error`, which you may also
|
||||
/// confused with [`std::io::Error`] or [`std::error::Error`], which you may also
|
||||
/// have in scope.
|
||||
///
|
||||
/// [`std::io::Error`]: ../../std/io/struct.Error.html
|
||||
/// [`std::error::Error`]: ../../std/error/trait.Error.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```rust
|
||||
|
|
|
@ -50,7 +50,7 @@ struct MarkSymbolVisitor<'a, 'tcx: 'a> {
|
|||
tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
||||
tables: &'a ty::TypeckTables<'tcx>,
|
||||
live_symbols: Box<FxHashSet<ast::NodeId>>,
|
||||
struct_has_extern_repr: bool,
|
||||
repr_has_repr_c: bool,
|
||||
in_pat: bool,
|
||||
inherited_pub_visibility: bool,
|
||||
ignore_variant_stack: Vec<DefId>,
|
||||
|
@ -102,7 +102,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
|
|||
fn handle_field_access(&mut self, lhs: &hir::Expr, name: ast::Name) {
|
||||
match self.tables.expr_ty_adjusted(lhs).sty {
|
||||
ty::TyAdt(def, _) => {
|
||||
self.insert_def_id(def.struct_variant().field_named(name).did);
|
||||
self.insert_def_id(def.non_enum_variant().field_named(name).did);
|
||||
}
|
||||
_ => span_bug!(lhs.span, "named field access on non-ADT"),
|
||||
}
|
||||
|
@ -111,7 +111,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
|
|||
fn handle_tup_field_access(&mut self, lhs: &hir::Expr, idx: usize) {
|
||||
match self.tables.expr_ty_adjusted(lhs).sty {
|
||||
ty::TyAdt(def, _) => {
|
||||
self.insert_def_id(def.struct_variant().fields[idx].did);
|
||||
self.insert_def_id(def.non_enum_variant().fields[idx].did);
|
||||
}
|
||||
ty::TyTuple(..) => {}
|
||||
_ => span_bug!(lhs.span, "numeric field access on non-ADT"),
|
||||
|
@ -149,8 +149,8 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
|
|||
}
|
||||
|
||||
fn visit_node(&mut self, node: &hir_map::Node<'tcx>) {
|
||||
let had_extern_repr = self.struct_has_extern_repr;
|
||||
self.struct_has_extern_repr = false;
|
||||
let had_repr_c = self.repr_has_repr_c;
|
||||
self.repr_has_repr_c = false;
|
||||
let had_inherited_pub_visibility = self.inherited_pub_visibility;
|
||||
self.inherited_pub_visibility = false;
|
||||
match *node {
|
||||
|
@ -159,7 +159,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
|
|||
hir::ItemStruct(..) | hir::ItemUnion(..) => {
|
||||
let def_id = self.tcx.hir.local_def_id(item.id);
|
||||
let def = self.tcx.adt_def(def_id);
|
||||
self.struct_has_extern_repr = def.repr.c();
|
||||
self.repr_has_repr_c = def.repr.c();
|
||||
|
||||
intravisit::walk_item(self, &item);
|
||||
}
|
||||
|
@ -187,7 +187,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
|
|||
}
|
||||
_ => ()
|
||||
}
|
||||
self.struct_has_extern_repr = had_extern_repr;
|
||||
self.repr_has_repr_c = had_repr_c;
|
||||
self.inherited_pub_visibility = had_inherited_pub_visibility;
|
||||
}
|
||||
|
||||
|
@ -223,10 +223,10 @@ impl<'a, 'tcx> Visitor<'tcx> for MarkSymbolVisitor<'a, 'tcx> {
|
|||
|
||||
fn visit_variant_data(&mut self, def: &'tcx hir::VariantData, _: ast::Name,
|
||||
_: &hir::Generics, _: ast::NodeId, _: syntax_pos::Span) {
|
||||
let has_extern_repr = self.struct_has_extern_repr;
|
||||
let has_repr_c = self.repr_has_repr_c;
|
||||
let inherited_pub_visibility = self.inherited_pub_visibility;
|
||||
let live_fields = def.fields().iter().filter(|f| {
|
||||
has_extern_repr || inherited_pub_visibility || f.vis == hir::Public
|
||||
has_repr_c || inherited_pub_visibility || f.vis == hir::Public
|
||||
});
|
||||
self.live_symbols.extend(live_fields.map(|f| f.id));
|
||||
|
||||
|
@ -428,7 +428,7 @@ fn find_live<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
|||
tcx,
|
||||
tables: &ty::TypeckTables::empty(None),
|
||||
live_symbols: box FxHashSet(),
|
||||
struct_has_extern_repr: false,
|
||||
repr_has_repr_c: false,
|
||||
in_pat: false,
|
||||
inherited_pub_visibility: false,
|
||||
ignore_variant_stack: vec![],
|
||||
|
|
|
@ -663,7 +663,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
|
|||
match with_cmt.ty.sty {
|
||||
ty::TyAdt(adt, substs) if adt.is_struct() => {
|
||||
// Consume those fields of the with expression that are needed.
|
||||
for with_field in &adt.struct_variant().fields {
|
||||
for with_field in &adt.non_enum_variant().fields {
|
||||
if !contains_field_named(with_field, fields) {
|
||||
let cmt_field = self.mc.cat_field(
|
||||
&*with_expr,
|
||||
|
|
|
@ -1248,7 +1248,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
|
|||
Def::StructCtor(_, CtorKind::Fn) => {
|
||||
match self.pat_ty(&pat)?.sty {
|
||||
ty::TyAdt(adt_def, _) => {
|
||||
(cmt, adt_def.struct_variant().fields.len())
|
||||
(cmt, adt_def.non_enum_variant().fields.len())
|
||||
}
|
||||
ref ty => {
|
||||
span_bug!(pat.span, "tuple struct pattern unexpected type {:?}", ty);
|
||||
|
|
|
@ -1084,8 +1084,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
|
|||
"omit landing pads for unwinding"),
|
||||
fewer_names: bool = (false, parse_bool, [TRACKED],
|
||||
"reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR)"),
|
||||
debug_llvm: bool = (false, parse_bool, [UNTRACKED],
|
||||
"enable debug output from LLVM"),
|
||||
meta_stats: bool = (false, parse_bool, [UNTRACKED],
|
||||
"gather metadata statistics"),
|
||||
print_link_args: bool = (false, parse_bool, [UNTRACKED],
|
||||
|
@ -2747,8 +2745,6 @@ mod tests {
|
|||
assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
|
||||
opts.debugging_opts.borrowck_stats = true;
|
||||
assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
|
||||
opts.debugging_opts.debug_llvm = true;
|
||||
assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
|
||||
opts.debugging_opts.meta_stats = true;
|
||||
assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
|
||||
opts.debugging_opts.print_link_args = true;
|
||||
|
|
|
@ -2295,6 +2295,13 @@ impl<'a, 'tcx> TyLayout<'tcx> {
|
|||
}, niche_start))
|
||||
};
|
||||
|
||||
// Locals variables which live across yields are stored
|
||||
// in the generator type as fields. These may be uninitialized
|
||||
// so we don't look for niches there.
|
||||
if let ty::TyGenerator(..) = self.ty.sty {
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
match self.abi {
|
||||
Abi::Scalar(ref scalar) => {
|
||||
return Ok(scalar_component(scalar, Size::from_bytes(0)));
|
||||
|
|
|
@ -1538,7 +1538,7 @@ impl ReprOptions {
|
|||
for attr in tcx.get_attrs(did).iter() {
|
||||
for r in attr::find_repr_attrs(tcx.sess.diagnostic(), attr) {
|
||||
flags.insert(match r {
|
||||
attr::ReprExtern => ReprFlags::IS_C,
|
||||
attr::ReprC => ReprFlags::IS_C,
|
||||
attr::ReprPacked => ReprFlags::IS_PACKED,
|
||||
attr::ReprSimd => ReprFlags::IS_SIMD,
|
||||
attr::ReprInt(i) => {
|
||||
|
@ -1691,10 +1691,9 @@ impl<'a, 'gcx, 'tcx> AdtDef {
|
|||
self.destructor(tcx).is_some()
|
||||
}
|
||||
|
||||
/// Asserts this is a struct and returns the struct's unique
|
||||
/// variant.
|
||||
pub fn struct_variant(&self) -> &VariantDef {
|
||||
assert!(!self.is_enum());
|
||||
/// Asserts this is a struct or union and returns its unique variant.
|
||||
pub fn non_enum_variant(&self) -> &VariantDef {
|
||||
assert!(self.is_struct() || self.is_union());
|
||||
&self.variants[0]
|
||||
}
|
||||
|
||||
|
@ -1733,7 +1732,7 @@ impl<'a, 'gcx, 'tcx> AdtDef {
|
|||
match def {
|
||||
Def::Variant(vid) | Def::VariantCtor(vid, ..) => self.variant_with_id(vid),
|
||||
Def::Struct(..) | Def::StructCtor(..) | Def::Union(..) |
|
||||
Def::TyAlias(..) | Def::AssociatedTy(..) | Def::SelfTy(..) => self.struct_variant(),
|
||||
Def::TyAlias(..) | Def::AssociatedTy(..) | Def::SelfTy(..) => self.non_enum_variant(),
|
||||
_ => bug!("unexpected def {:?} in variant_of_def", def)
|
||||
}
|
||||
}
|
||||
|
@ -2319,11 +2318,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
|||
self.adt_def(enum_did).variant_with_id(did)
|
||||
}
|
||||
Def::Struct(did) | Def::Union(did) => {
|
||||
self.adt_def(did).struct_variant()
|
||||
self.adt_def(did).non_enum_variant()
|
||||
}
|
||||
Def::StructCtor(ctor_did, ..) => {
|
||||
let did = self.parent_def_id(ctor_did).expect("struct ctor has no parent");
|
||||
self.adt_def(did).struct_variant()
|
||||
self.adt_def(did).non_enum_variant()
|
||||
}
|
||||
_ => bug!("expect_variant_def used with unexpected def {:?}", def)
|
||||
}
|
||||
|
|
|
@ -1351,7 +1351,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
|
|||
pub fn simd_type(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> {
|
||||
match self.sty {
|
||||
TyAdt(def, substs) => {
|
||||
def.struct_variant().fields[0].ty(tcx, substs)
|
||||
def.non_enum_variant().fields[0].ty(tcx, substs)
|
||||
}
|
||||
_ => bug!("simd_type called on invalid type")
|
||||
}
|
||||
|
@ -1359,7 +1359,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
|
|||
|
||||
pub fn simd_size(&self, _cx: TyCtxt) -> usize {
|
||||
match self.sty {
|
||||
TyAdt(def, _) => def.struct_variant().fields.len(),
|
||||
TyAdt(def, _) => def.non_enum_variant().fields.len(),
|
||||
_ => bug!("simd_size called on invalid type")
|
||||
}
|
||||
}
|
||||
|
|
|
@ -258,7 +258,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
|||
adt.variant_with_id(vid).fields.get(i).map(|f| f.ty(self, substs))
|
||||
}
|
||||
(&TyAdt(adt, substs), None) => {
|
||||
// Don't use `struct_variant`, this may be a univariant enum.
|
||||
// Don't use `non_enum_variant`, this may be a univariant enum.
|
||||
adt.variants[0].fields.get(i).map(|f| f.ty(self, substs))
|
||||
}
|
||||
(&TyTuple(ref v, _), None) => v.get(i).cloned(),
|
||||
|
@ -277,7 +277,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
|||
adt.variant_with_id(vid).find_field_named(n).map(|f| f.ty(self, substs))
|
||||
}
|
||||
(&TyAdt(adt, substs), None) => {
|
||||
adt.struct_variant().find_field_named(n).map(|f| f.ty(self, substs))
|
||||
adt.non_enum_variant().find_field_named(n).map(|f| f.ty(self, substs))
|
||||
}
|
||||
_ => return None
|
||||
}
|
||||
|
@ -293,7 +293,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
|||
if !def.is_struct() {
|
||||
break;
|
||||
}
|
||||
match def.struct_variant().fields.last() {
|
||||
match def.non_enum_variant().fields.last() {
|
||||
Some(f) => ty = f.ty(self, substs),
|
||||
None => break,
|
||||
}
|
||||
|
@ -329,7 +329,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
|
|||
match (&a.sty, &b.sty) {
|
||||
(&TyAdt(a_def, a_substs), &TyAdt(b_def, b_substs))
|
||||
if a_def == b_def && a_def.is_struct() => {
|
||||
if let Some(f) = a_def.struct_variant().fields.last() {
|
||||
if let Some(f) = a_def.non_enum_variant().fields.last() {
|
||||
a = f.ty(self, a_substs);
|
||||
b = f.ty(self, b_substs);
|
||||
} else {
|
||||
|
|
|
@ -107,7 +107,7 @@ impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> {
|
|||
ty::TyAdt(adt_def, _) if adt_def.is_union() => match result {
|
||||
RestrictionResult::Safe => RestrictionResult::Safe,
|
||||
RestrictionResult::SafeIf(base_lp, mut base_vec) => {
|
||||
for field in &adt_def.struct_variant().fields {
|
||||
for field in &adt_def.non_enum_variant().fields {
|
||||
let field = InteriorKind::InteriorField(mc::NamedField(field.name));
|
||||
let field_ty = if field == interior {
|
||||
cmt.ty
|
||||
|
|
|
@ -343,7 +343,7 @@ impl<'a, 'tcx> MoveData<'tcx> {
|
|||
if let (&ty::TyAdt(adt_def, _), LpInterior(opt_variant_id, interior))
|
||||
= (&base_lp.ty.sty, lp_elem) {
|
||||
if adt_def.is_union() {
|
||||
for field in &adt_def.struct_variant().fields {
|
||||
for field in &adt_def.non_enum_variant().fields {
|
||||
let field = InteriorKind::InteriorField(mc::NamedField(field.name));
|
||||
if field != interior {
|
||||
let sibling_lp_kind =
|
||||
|
@ -395,7 +395,7 @@ impl<'a, 'tcx> MoveData<'tcx> {
|
|||
if let LpExtend(ref base_lp, mutbl, LpInterior(opt_variant_id, interior)) = lp.kind {
|
||||
if let ty::TyAdt(adt_def, _) = base_lp.ty.sty {
|
||||
if adt_def.is_union() {
|
||||
for field in &adt_def.struct_variant().fields {
|
||||
for field in &adt_def.non_enum_variant().fields {
|
||||
let field = InteriorKind::InteriorField(mc::NamedField(field.name));
|
||||
let field_ty = if field == interior {
|
||||
lp.ty
|
||||
|
|
|
@ -167,7 +167,6 @@ mod rustc_trans {
|
|||
pub use rustc_trans_utils::trans_crate::TranslatedCrate as CrateTranslation;
|
||||
|
||||
pub fn init(_sess: &Session) {}
|
||||
pub fn enable_llvm_debug() {}
|
||||
pub fn print_version() {}
|
||||
pub fn print_passes() {}
|
||||
pub fn print(_req: PrintRequest, _sess: &Session) {}
|
||||
|
@ -205,10 +204,6 @@ pub fn run_compiler<'a>(args: &[String],
|
|||
|
||||
let (sopts, cfg) = config::build_session_options_and_crate_config(&matches);
|
||||
|
||||
if sopts.debugging_opts.debug_llvm {
|
||||
rustc_trans::enable_llvm_debug();
|
||||
}
|
||||
|
||||
let descriptions = diagnostics_registry();
|
||||
|
||||
do_or_return!(callbacks.early_callback(&matches,
|
||||
|
|
|
@ -120,17 +120,15 @@ impl LintPass for NonCamelCaseTypes {
|
|||
|
||||
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCamelCaseTypes {
|
||||
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
|
||||
let extern_repr_count = it.attrs
|
||||
let has_repr_c = it.attrs
|
||||
.iter()
|
||||
.filter(|attr| {
|
||||
.any(|attr| {
|
||||
attr::find_repr_attrs(cx.tcx.sess.diagnostic(), attr)
|
||||
.iter()
|
||||
.any(|r| r == &attr::ReprExtern)
|
||||
})
|
||||
.count();
|
||||
let has_extern_repr = extern_repr_count > 0;
|
||||
.any(|r| r == &attr::ReprC)
|
||||
});
|
||||
|
||||
if has_extern_repr {
|
||||
if has_repr_c {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -422,7 +422,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
|
|||
consider adding a #[repr(C)] attribute to the type");
|
||||
}
|
||||
|
||||
if def.struct_variant().fields.is_empty() {
|
||||
if def.non_enum_variant().fields.is_empty() {
|
||||
return FfiUnsafe("found zero-size struct in foreign module, consider \
|
||||
adding a member to this struct");
|
||||
}
|
||||
|
@ -430,7 +430,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
|
|||
// We can't completely trust repr(C) markings; make sure the
|
||||
// fields are actually safe.
|
||||
let mut all_phantom = true;
|
||||
for field in &def.struct_variant().fields {
|
||||
for field in &def.non_enum_variant().fields {
|
||||
let field_ty = cx.fully_normalize_associated_types_in(
|
||||
&field.ty(cx, substs)
|
||||
);
|
||||
|
@ -458,13 +458,13 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
|
|||
consider adding a #[repr(C)] attribute to the type");
|
||||
}
|
||||
|
||||
if def.struct_variant().fields.is_empty() {
|
||||
if def.non_enum_variant().fields.is_empty() {
|
||||
return FfiUnsafe("found zero-size union in foreign module, consider \
|
||||
adding a member to this union");
|
||||
}
|
||||
|
||||
let mut all_phantom = true;
|
||||
for field in &def.struct_variant().fields {
|
||||
for field in &def.non_enum_variant().fields {
|
||||
let field_ty = cx.fully_normalize_associated_types_in(
|
||||
&field.ty(cx, substs)
|
||||
);
|
||||
|
|
|
@ -1315,9 +1315,6 @@ extern "C" {
|
|||
ElementCount: c_uint,
|
||||
Packed: Bool);
|
||||
|
||||
/// Enables LLVM debug output.
|
||||
pub fn LLVMRustSetDebug(Enabled: c_int);
|
||||
|
||||
/// Prepares inline assembly.
|
||||
pub fn LLVMRustInlineAsm(Ty: TypeRef,
|
||||
AsmString: *const c_char,
|
||||
|
@ -1610,7 +1607,6 @@ extern "C" {
|
|||
pub fn LLVMRustSetNormalizedTarget(M: ModuleRef, triple: *const c_char);
|
||||
pub fn LLVMRustAddAlwaysInlinePass(P: PassManagerBuilderRef, AddLifetimes: bool);
|
||||
pub fn LLVMRustLinkInExternalBitcode(M: ModuleRef, bc: *const c_char, len: size_t) -> bool;
|
||||
pub fn LLVMRustLinkInParsedExternalBitcode(M: ModuleRef, M: ModuleRef) -> bool;
|
||||
pub fn LLVMRustRunRestrictionPass(M: ModuleRef, syms: *const *const c_char, len: size_t);
|
||||
pub fn LLVMRustMarkAllFunctionsNounwind(M: ModuleRef);
|
||||
|
||||
|
@ -1646,8 +1642,6 @@ extern "C" {
|
|||
pub fn LLVMRustWriteDiagnosticInfoToString(DI: DiagnosticInfoRef, s: RustStringRef);
|
||||
pub fn LLVMRustGetDiagInfoKind(DI: DiagnosticInfoRef) -> DiagnosticKind;
|
||||
|
||||
pub fn LLVMRustWriteDebugLocToString(C: ContextRef, DL: DebugLocRef, s: RustStringRef);
|
||||
|
||||
pub fn LLVMRustSetInlineAsmDiagnosticHandler(C: ContextRef,
|
||||
H: InlineAsmDiagHandler,
|
||||
CX: *mut c_void);
|
||||
|
|
|
@ -296,11 +296,6 @@ pub unsafe fn twine_to_string(tr: TwineRef) -> String {
|
|||
build_string(|s| LLVMRustWriteTwineToString(tr, s)).expect("got a non-UTF8 Twine from LLVM")
|
||||
}
|
||||
|
||||
pub unsafe fn debug_loc_to_string(c: ContextRef, tr: DebugLocRef) -> String {
|
||||
build_string(|s| LLVMRustWriteDebugLocToString(c, tr, s))
|
||||
.expect("got a non-UTF8 DebugLoc from LLVM")
|
||||
}
|
||||
|
||||
pub fn initialize_available_targets() {
|
||||
macro_rules! init_target(
|
||||
($cfg:meta, $($method:ident),*) => { {
|
||||
|
|
|
@ -625,7 +625,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
|
|||
debug!("IsolatedEncoder::encode_struct_ctor({:?})", def_id);
|
||||
let tcx = self.tcx;
|
||||
let adt_def = tcx.adt_def(adt_def_id);
|
||||
let variant = adt_def.struct_variant();
|
||||
let variant = adt_def.non_enum_variant();
|
||||
|
||||
let data = VariantData {
|
||||
ctor_kind: variant.ctor_kind,
|
||||
|
@ -935,7 +935,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
|
|||
hir::ItemTy(..) => EntryKind::Type,
|
||||
hir::ItemEnum(..) => EntryKind::Enum(get_repr_options(&tcx, def_id)),
|
||||
hir::ItemStruct(ref struct_def, _) => {
|
||||
let variant = tcx.adt_def(def_id).struct_variant();
|
||||
let variant = tcx.adt_def(def_id).non_enum_variant();
|
||||
|
||||
// Encode def_ids for each field and method
|
||||
// for methods, write all the stuff get_trait_method
|
||||
|
@ -956,7 +956,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
|
|||
}), repr_options)
|
||||
}
|
||||
hir::ItemUnion(..) => {
|
||||
let variant = tcx.adt_def(def_id).struct_variant();
|
||||
let variant = tcx.adt_def(def_id).non_enum_variant();
|
||||
let repr_options = get_repr_options(&tcx, def_id);
|
||||
|
||||
EntryKind::Union(self.lazy(&VariantData {
|
||||
|
@ -1049,7 +1049,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
|
|||
hir::ItemStruct(..) |
|
||||
hir::ItemUnion(..) => {
|
||||
let def = self.tcx.adt_def(def_id);
|
||||
self.lazy_seq(def.struct_variant().fields.iter().map(|f| {
|
||||
self.lazy_seq(def.non_enum_variant().fields.iter().map(|f| {
|
||||
assert!(f.did.is_local());
|
||||
f.did.index
|
||||
}))
|
||||
|
|
|
@ -719,7 +719,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
|
|||
ty::TyAdt(def, _) => if def.is_enum() {
|
||||
format!("{}", field.index())
|
||||
} else {
|
||||
format!("{}", def.struct_variant().fields[field.index()].name)
|
||||
format!("{}", def.non_enum_variant().fields[field.index()].name)
|
||||
},
|
||||
ty::TyTuple(_, _) => format!("{}", field.index()),
|
||||
ty::TyRef(_, tnm) | ty::TyRawPtr(tnm) => {
|
||||
|
|
|
@ -488,7 +488,7 @@ fn check_ctfe_against_miri<'a, 'tcx>(
|
|||
miri_place = ecx.place_downcast(miri_place, variant).unwrap();
|
||||
&def.variants[variant]
|
||||
} else {
|
||||
def.struct_variant()
|
||||
def.non_enum_variant()
|
||||
};
|
||||
let vec = match ctfe {
|
||||
ConstVal::Aggregate(Struct(v)) => v,
|
||||
|
|
|
@ -838,8 +838,8 @@ fn find_vtable_types_for_unsizing<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
|||
CustomCoerceUnsized::Struct(i) => i
|
||||
};
|
||||
|
||||
let source_fields = &source_adt_def.struct_variant().fields;
|
||||
let target_fields = &target_adt_def.struct_variant().fields;
|
||||
let source_fields = &source_adt_def.non_enum_variant().fields;
|
||||
let target_fields = &target_adt_def.non_enum_variant().fields;
|
||||
|
||||
assert!(coerce_index < source_fields.len() &&
|
||||
source_fields.len() == target_fields.len());
|
||||
|
|
|
@ -1583,10 +1583,12 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc
|
|||
if !self.span.filter_generated(sub_span, ex.span) {
|
||||
let span =
|
||||
self.span_from_span(sub_span.expect("No span found for var ref"));
|
||||
let ref_id =
|
||||
::id_from_def_id(def.non_enum_variant().fields[idx.node].did);
|
||||
self.dumper.dump_ref(Ref {
|
||||
kind: RefKind::Variable,
|
||||
span,
|
||||
ref_id: ::id_from_def_id(def.struct_variant().fields[idx.node].did),
|
||||
ref_id,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
|
@ -528,7 +528,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
|
|||
};
|
||||
match self.tables.expr_ty_adjusted(&hir_node).sty {
|
||||
ty::TyAdt(def, _) if !def.is_enum() => {
|
||||
let f = def.struct_variant().field_named(ident.node.name);
|
||||
let f = def.non_enum_variant().field_named(ident.node.name);
|
||||
let sub_span = self.span_utils.span_for_last_ident(expr.span);
|
||||
filter!(self.span_utils, sub_span, expr.span, None);
|
||||
let span = self.span_from_span(sub_span.unwrap());
|
||||
|
|
|
@ -969,7 +969,7 @@ fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
|
|||
let struct_name = compute_debuginfo_type_name(cx, struct_type, false);
|
||||
|
||||
let (struct_def_id, variant) = match struct_type.sty {
|
||||
ty::TyAdt(def, _) => (def.did, def.struct_variant()),
|
||||
ty::TyAdt(def, _) => (def.did, def.non_enum_variant()),
|
||||
_ => bug!("prepare_struct_metadata on a non-ADT")
|
||||
};
|
||||
|
||||
|
@ -1084,7 +1084,7 @@ fn prepare_union_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
|
|||
let union_name = compute_debuginfo_type_name(cx, union_type, false);
|
||||
|
||||
let (union_def_id, variant) = match union_type.sty {
|
||||
ty::TyAdt(def, _) => (def.did, def.struct_variant()),
|
||||
ty::TyAdt(def, _) => (def.did, def.non_enum_variant()),
|
||||
_ => bug!("prepare_union_metadata on a non-ADT")
|
||||
};
|
||||
|
||||
|
|
|
@ -69,7 +69,7 @@ pub use base::trans_crate;
|
|||
use back::bytecode::RLIB_BYTECODE_EXTENSION;
|
||||
|
||||
pub use metadata::LlvmMetadataLoader;
|
||||
pub use llvm_util::{init, target_features, print_version, print_passes, print, enable_llvm_debug};
|
||||
pub use llvm_util::{init, target_features, print_version, print_passes, print};
|
||||
|
||||
use std::any::Any;
|
||||
use std::path::PathBuf;
|
||||
|
|
|
@ -140,7 +140,3 @@ pub fn print(req: PrintRequest, sess: &Session) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn enable_llvm_debug() {
|
||||
unsafe { llvm::LLVMRustSetDebug(1); }
|
||||
}
|
||||
|
|
|
@ -107,7 +107,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
ty::TyDynamic(ref tty, ..) =>
|
||||
Some(PointerKind::Vtable(tty.principal().map(|p| p.def_id()))),
|
||||
ty::TyAdt(def, substs) if def.is_struct() => {
|
||||
match def.struct_variant().fields.last() {
|
||||
match def.non_enum_variant().fields.last() {
|
||||
None => Some(PointerKind::Thin),
|
||||
Some(f) => {
|
||||
let field_ty = self.field_ty(span, f, substs);
|
||||
|
|
|
@ -289,7 +289,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
for (ty, _) in self.autoderef(span, rcvr_ty) {
|
||||
match ty.sty {
|
||||
ty::TyAdt(def, substs) if !def.is_enum() => {
|
||||
if let Some(field) = def.struct_variant()
|
||||
if let Some(field) = def.non_enum_variant()
|
||||
.find_field_named(item_name) {
|
||||
let snippet = tcx.sess.codemap().span_to_snippet(expr.span);
|
||||
let expr_string = match snippet {
|
||||
|
|
|
@ -1444,7 +1444,7 @@ pub fn check_simd<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span, def_id: DefId
|
|||
let t = tcx.type_of(def_id);
|
||||
match t.sty {
|
||||
ty::TyAdt(def, substs) if def.is_struct() => {
|
||||
let fields = &def.struct_variant().fields;
|
||||
let fields = &def.non_enum_variant().fields;
|
||||
if fields.is_empty() {
|
||||
span_err!(tcx.sess, sp, E0075, "SIMD vector cannot be empty");
|
||||
return;
|
||||
|
@ -1498,7 +1498,7 @@ fn check_packed_inner<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
|||
}
|
||||
// push struct def_id before checking fields
|
||||
stack.push(def_id);
|
||||
for field in &def.struct_variant().fields {
|
||||
for field in &def.non_enum_variant().fields {
|
||||
let f = field.ty(tcx, substs);
|
||||
match f.sty {
|
||||
ty::TyAdt(def, _) => {
|
||||
|
@ -2945,7 +2945,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
debug!("struct named {:?}", base_t);
|
||||
let (ident, def_scope) =
|
||||
self.tcx.adjust(field.node, base_def.did, self.body_id);
|
||||
let fields = &base_def.struct_variant().fields;
|
||||
let fields = &base_def.non_enum_variant().fields;
|
||||
if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
|
||||
let field_ty = self.field_ty(expr.span, field, substs);
|
||||
if field.vis.is_accessible_from(def_scope, self.tcx) {
|
||||
|
@ -2993,12 +2993,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
match expr_t.sty {
|
||||
ty::TyAdt(def, _) if !def.is_enum() => {
|
||||
if let Some(suggested_field_name) =
|
||||
Self::suggest_field_name(def.struct_variant(), field, vec![]) {
|
||||
Self::suggest_field_name(def.non_enum_variant(), field, vec![]) {
|
||||
err.span_label(field.span,
|
||||
format!("did you mean `{}`?", suggested_field_name));
|
||||
} else {
|
||||
err.span_label(field.span, "unknown field");
|
||||
let struct_variant_def = def.struct_variant();
|
||||
let struct_variant_def = def.non_enum_variant();
|
||||
let field_names = self.available_field_names(struct_variant_def);
|
||||
if !field_names.is_empty() {
|
||||
err.note(&format!("available fields are: {}",
|
||||
|
@ -3080,7 +3080,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
while let Some((base_t, _)) = autoderef.next() {
|
||||
let field = match base_t.sty {
|
||||
ty::TyAdt(base_def, substs) if base_def.is_struct() => {
|
||||
tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
|
||||
tuple_like = base_def.non_enum_variant().ctor_kind == CtorKind::Fn;
|
||||
if !tuple_like { continue }
|
||||
|
||||
debug!("tuple struct named {:?}", base_t);
|
||||
|
@ -3090,7 +3090,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
};
|
||||
let (ident, def_scope) =
|
||||
self.tcx.adjust_ident(ident, base_def.did, self.body_id);
|
||||
let fields = &base_def.struct_variant().fields;
|
||||
let fields = &base_def.non_enum_variant().fields;
|
||||
if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
|
||||
let field_ty = self.field_ty(expr.span, field, substs);
|
||||
if field.vis.is_accessible_from(def_scope, self.tcx) {
|
||||
|
@ -3350,7 +3350,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
Def::AssociatedTy(..) | Def::SelfTy(..) => {
|
||||
match ty.sty {
|
||||
ty::TyAdt(adt, substs) if !adt.is_enum() => {
|
||||
Some((adt.struct_variant(), adt.did, substs))
|
||||
Some((adt.non_enum_variant(), adt.did, substs))
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
|
@ -3412,7 +3412,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
self.check_expr_has_type_or_error(base_expr, struct_ty);
|
||||
match struct_ty.sty {
|
||||
ty::TyAdt(adt, substs) if adt.is_struct() => {
|
||||
let fru_field_types = adt.struct_variant().fields.iter().map(|f| {
|
||||
let fru_field_types = adt.non_enum_variant().fields.iter().map(|f| {
|
||||
self.normalize_associated_types_in(expr.span, &f.ty(self.tcx, substs))
|
||||
}).collect();
|
||||
|
||||
|
|
|
@ -130,14 +130,14 @@ impl<'a, 'gcx> CheckTypeWellFormedVisitor<'a, 'gcx> {
|
|||
}
|
||||
hir::ItemStruct(ref struct_def, ref ast_generics) => {
|
||||
self.check_type_defn(item, false, |fcx| {
|
||||
vec![fcx.struct_variant(struct_def)]
|
||||
vec![fcx.non_enum_variant(struct_def)]
|
||||
});
|
||||
|
||||
self.check_variances_for_type_defn(item, ast_generics);
|
||||
}
|
||||
hir::ItemUnion(ref struct_def, ref ast_generics) => {
|
||||
self.check_type_defn(item, true, |fcx| {
|
||||
vec![fcx.struct_variant(struct_def)]
|
||||
vec![fcx.non_enum_variant(struct_def)]
|
||||
});
|
||||
|
||||
self.check_variances_for_type_defn(item, ast_generics);
|
||||
|
@ -689,7 +689,7 @@ struct AdtField<'tcx> {
|
|||
}
|
||||
|
||||
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
||||
fn struct_variant(&self, struct_def: &hir::VariantData) -> AdtVariant<'tcx> {
|
||||
fn non_enum_variant(&self, struct_def: &hir::VariantData) -> AdtVariant<'tcx> {
|
||||
let fields =
|
||||
struct_def.fields().iter()
|
||||
.map(|field| {
|
||||
|
@ -704,7 +704,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
|
|||
|
||||
fn enum_variants(&self, enum_def: &hir::EnumDef) -> Vec<AdtVariant<'tcx>> {
|
||||
enum_def.variants.iter()
|
||||
.map(|variant| self.struct_variant(&variant.node.data))
|
||||
.map(|variant| self.non_enum_variant(&variant.node.data))
|
||||
.collect()
|
||||
}
|
||||
|
||||
|
|
|
@ -288,7 +288,7 @@ pub fn coerce_unsized_info<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
|||
// conversion). This will work out because `U:
|
||||
// Unsize<V>`, and we have a builtin rule that `*mut
|
||||
// U` can be coerced to `*mut V` if `U: Unsize<V>`.
|
||||
let fields = &def_a.struct_variant().fields;
|
||||
let fields = &def_a.non_enum_variant().fields;
|
||||
let diff_fields = fields.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(i, f)| {
|
||||
|
|
|
@ -186,7 +186,7 @@ fn build_enum(cx: &DocContext, did: DefId) -> clean::Enum {
|
|||
|
||||
fn build_struct(cx: &DocContext, did: DefId) -> clean::Struct {
|
||||
let predicates = cx.tcx.predicates_of(did);
|
||||
let variant = cx.tcx.adt_def(did).struct_variant();
|
||||
let variant = cx.tcx.adt_def(did).non_enum_variant();
|
||||
|
||||
clean::Struct {
|
||||
struct_type: match variant.ctor_kind {
|
||||
|
@ -202,7 +202,7 @@ fn build_struct(cx: &DocContext, did: DefId) -> clean::Struct {
|
|||
|
||||
fn build_union(cx: &DocContext, did: DefId) -> clean::Union {
|
||||
let predicates = cx.tcx.predicates_of(did);
|
||||
let variant = cx.tcx.adt_def(did).struct_variant();
|
||||
let variant = cx.tcx.adt_def(did).non_enum_variant();
|
||||
|
||||
clean::Union {
|
||||
struct_type: doctree::Plain,
|
||||
|
|
|
@ -23,6 +23,7 @@ use rustc::hir::def::Def;
|
|||
use rustc::hir::def_id::{DefId, LOCAL_CRATE};
|
||||
use rustc::middle::cstore::{LoadedMacro, CrateStore};
|
||||
use rustc::middle::privacy::AccessLevel;
|
||||
use rustc::ty::Visibility;
|
||||
use rustc::util::nodemap::FxHashSet;
|
||||
|
||||
use rustc::hir;
|
||||
|
@ -204,7 +205,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
|
|||
self.inside_public_path = orig_inside_public_path;
|
||||
let def_id = self.cx.tcx.hir.local_def_id(id);
|
||||
if let Some(exports) = self.cx.tcx.module_exports(def_id) {
|
||||
for export in exports.iter() {
|
||||
for export in exports.iter().filter(|e| e.vis == Visibility::Public) {
|
||||
if let Def::Macro(def_id, ..) = export.def {
|
||||
if def_id.krate == LOCAL_CRATE || self.reexported_macros.contains(&def_id) {
|
||||
continue // These are `krate.exported_macros`, handled in `self.visit()`.
|
||||
|
|
|
@ -1241,6 +1241,46 @@ impl<K, V, S> HashMap<K, V, S>
|
|||
self.search_mut(k).into_occupied_bucket().map(|bucket| pop_internal(bucket).1)
|
||||
}
|
||||
|
||||
/// Removes a key from the map, returning the stored key and value if the
|
||||
/// key was previously in the map.
|
||||
///
|
||||
/// The key may be any borrowed form of the map's key type, but
|
||||
/// [`Hash`] and [`Eq`] on the borrowed form *must* match those for
|
||||
/// the key type.
|
||||
///
|
||||
/// [`Eq`]: ../../std/cmp/trait.Eq.html
|
||||
/// [`Hash`]: ../../std/hash/trait.Hash.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// #![feature(hash_map_remove_entry)]
|
||||
/// use std::collections::HashMap;
|
||||
///
|
||||
/// # fn main() {
|
||||
/// let mut map = HashMap::new();
|
||||
/// map.insert(1, "a");
|
||||
/// assert_eq!(map.remove_entry(&1), Some((1, "a")));
|
||||
/// assert_eq!(map.remove(&1), None);
|
||||
/// # }
|
||||
/// ```
|
||||
#[unstable(feature = "hash_map_remove_entry", issue = "46344")]
|
||||
pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)>
|
||||
where K: Borrow<Q>,
|
||||
Q: Hash + Eq
|
||||
{
|
||||
if self.table.size() == 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
self.search_mut(k)
|
||||
.into_occupied_bucket()
|
||||
.map(|bucket| {
|
||||
let (k, v, _) = pop_internal(bucket);
|
||||
(k, v)
|
||||
})
|
||||
}
|
||||
|
||||
/// Retains only the elements specified by the predicate.
|
||||
///
|
||||
/// In other words, remove all pairs `(k, v)` such that `f(&k,&mut v)` returns `false`.
|
||||
|
@ -3040,13 +3080,21 @@ mod test_map {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_pop() {
|
||||
fn test_remove() {
|
||||
let mut m = HashMap::new();
|
||||
m.insert(1, 2);
|
||||
assert_eq!(m.remove(&1), Some(2));
|
||||
assert_eq!(m.remove(&1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_remove_entry() {
|
||||
let mut m = HashMap::new();
|
||||
m.insert(1, 2);
|
||||
assert_eq!(m.remove_entry(&1), Some((1, 2)));
|
||||
assert_eq!(m.remove(&1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_iterate() {
|
||||
let mut m = HashMap::with_capacity(4);
|
||||
|
|
|
@ -997,9 +997,9 @@ pub trait Write {
|
|||
///
|
||||
/// Calls to `write` are not guaranteed to block waiting for data to be
|
||||
/// written, and a write which would otherwise block can be indicated through
|
||||
/// an `Err` variant.
|
||||
/// an [`Err`] variant.
|
||||
///
|
||||
/// If the return value is `Ok(n)` then it must be guaranteed that
|
||||
/// If the return value is [`Ok(n)`] then it must be guaranteed that
|
||||
/// `0 <= n <= buf.len()`. A return value of `0` typically means that the
|
||||
/// underlying object is no longer able to accept bytes and will likely not
|
||||
/// be able to in the future as well, or that the buffer provided is empty.
|
||||
|
@ -1013,9 +1013,13 @@ pub trait Write {
|
|||
/// It is **not** considered an error if the entire buffer could not be
|
||||
/// written to this writer.
|
||||
///
|
||||
/// An error of the `ErrorKind::Interrupted` kind is non-fatal and the
|
||||
/// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the
|
||||
/// write operation should be retried if there is nothing else to do.
|
||||
///
|
||||
/// [`Err`]: ../../std/result/enum.Result.html#variant.Err
|
||||
/// [`Ok(n)`]: ../../std/result/enum.Result.html#variant.Ok
|
||||
/// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
|
@ -1061,17 +1065,20 @@ pub trait Write {
|
|||
|
||||
/// Attempts to write an entire buffer into this write.
|
||||
///
|
||||
/// This method will continuously call `write` until there is no more data
|
||||
/// to be written or an error of non-`ErrorKind::Interrupted` kind is
|
||||
/// This method will continuously call [`write`] until there is no more data
|
||||
/// to be written or an error of non-[`ErrorKind::Interrupted`] kind is
|
||||
/// returned. This method will not return until the entire buffer has been
|
||||
/// successfully written or such an error occurs. The first error that is
|
||||
/// not of `ErrorKind::Interrupted` kind generated from this method will be
|
||||
/// not of [`ErrorKind::Interrupted`] kind generated from this method will be
|
||||
/// returned.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// This function will return the first error of
|
||||
/// non-`ErrorKind::Interrupted` kind that `write` returns.
|
||||
/// non-[`ErrorKind::Interrupted`] kind that [`write`] returns.
|
||||
///
|
||||
/// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted
|
||||
/// [`write`]: #tymethod.write
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
|
|
|
@ -296,7 +296,6 @@
|
|||
#![feature(rand)]
|
||||
#![feature(raw)]
|
||||
#![feature(repr_align)]
|
||||
#![feature(repr_simd)]
|
||||
#![feature(rustc_attrs)]
|
||||
#![feature(shared)]
|
||||
#![feature(sip_hash_13)]
|
||||
|
|
|
@ -39,6 +39,7 @@ use os::raw::c_char;
|
|||
const DEBUG: bool = false;
|
||||
|
||||
pub mod args;
|
||||
#[cfg(feature = "backtrace")]
|
||||
pub mod backtrace;
|
||||
pub mod cmath;
|
||||
pub mod condvar;
|
||||
|
|
|
@ -20,11 +20,6 @@ use os::raw::c_ulonglong;
|
|||
use libc::{wchar_t, size_t, c_void};
|
||||
use ptr;
|
||||
|
||||
#[repr(simd)]
|
||||
#[repr(C)]
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
struct u64x2(u64, u64);
|
||||
|
||||
pub use self::FILE_INFO_BY_HANDLE_CLASS::*;
|
||||
pub use self::EXCEPTION_DISPOSITION::*;
|
||||
|
||||
|
@ -700,9 +695,8 @@ pub struct FLOATING_SAVE_AREA {
|
|||
}
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[repr(C)]
|
||||
#[repr(C, align(16))]
|
||||
pub struct CONTEXT {
|
||||
_align_hack: [u64x2; 0], // FIXME align on 16-byte
|
||||
pub P1Home: DWORDLONG,
|
||||
pub P2Home: DWORDLONG,
|
||||
pub P3Home: DWORDLONG,
|
||||
|
@ -760,17 +754,15 @@ pub struct CONTEXT {
|
|||
}
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[repr(C)]
|
||||
#[repr(C, align(16))]
|
||||
pub struct M128A {
|
||||
_align_hack: [u64x2; 0], // FIXME align on 16-byte
|
||||
pub Low: c_ulonglong,
|
||||
pub High: c_longlong
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[repr(C)]
|
||||
#[repr(C, align(16))]
|
||||
pub struct FLOATING_SAVE_AREA {
|
||||
_align_hack: [u64x2; 0], // FIXME align on 16-byte
|
||||
_Dummy: [u8; 512] // FIXME: Fill this out
|
||||
}
|
||||
|
||||
|
|
|
@ -1008,8 +1008,7 @@ pub fn find_repr_attrs(diagnostic: &Handler, attr: &Attribute) -> Vec<ReprAttr>
|
|||
if let Some(mi) = item.word() {
|
||||
let word = &*mi.name().as_str();
|
||||
let hint = match word {
|
||||
// Can't use "extern" because it's not a lexical identifier.
|
||||
"C" => Some(ReprExtern),
|
||||
"C" => Some(ReprC),
|
||||
"packed" => Some(ReprPacked),
|
||||
"simd" => Some(ReprSimd),
|
||||
_ => match int_type_of_word(word) {
|
||||
|
@ -1080,7 +1079,7 @@ fn int_type_of_word(s: &str) -> Option<IntType> {
|
|||
#[derive(PartialEq, Debug, RustcEncodable, RustcDecodable, Copy, Clone)]
|
||||
pub enum ReprAttr {
|
||||
ReprInt(IntType),
|
||||
ReprExtern,
|
||||
ReprC,
|
||||
ReprPacked,
|
||||
ReprSimd,
|
||||
ReprAlign(u32),
|
||||
|
|
|
@ -101,7 +101,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String {
|
|||
break;
|
||||
}
|
||||
}
|
||||
if i > line.len() {
|
||||
if i >= line.len() {
|
||||
can_trim = false;
|
||||
}
|
||||
if !can_trim {
|
||||
|
|
|
@ -831,7 +831,7 @@ fn find_repr_type_name(diagnostic: &Handler, type_attrs: &[ast::Attribute]) -> &
|
|||
for r in &attr::find_repr_attrs(diagnostic, a) {
|
||||
repr_type_name = match *r {
|
||||
attr::ReprPacked | attr::ReprSimd | attr::ReprAlign(_) => continue,
|
||||
attr::ReprExtern => "i32",
|
||||
attr::ReprC => "i32",
|
||||
|
||||
attr::ReprInt(attr::SignedInt(ast::IntTy::Isize)) => "isize",
|
||||
attr::ReprInt(attr::SignedInt(ast::IntTy::I8)) => "i8",
|
||||
|
|
|
@ -384,12 +384,6 @@ LLVMRustBuildAtomicFence(LLVMBuilderRef B, LLVMAtomicOrdering Order,
|
|||
return wrap(unwrap(B)->CreateFence(fromRust(Order), fromRust(Scope)));
|
||||
}
|
||||
|
||||
extern "C" void LLVMRustSetDebug(int Enabled) {
|
||||
#ifndef NDEBUG
|
||||
DebugFlag = Enabled;
|
||||
#endif
|
||||
}
|
||||
|
||||
enum class LLVMRustAsmDialect {
|
||||
Other,
|
||||
Att,
|
||||
|
@ -933,23 +927,6 @@ extern "C" bool LLVMRustLinkInExternalBitcode(LLVMModuleRef DstRef, char *BC,
|
|||
return true;
|
||||
}
|
||||
|
||||
extern "C" bool LLVMRustLinkInParsedExternalBitcode(
|
||||
LLVMModuleRef DstRef, LLVMModuleRef SrcRef) {
|
||||
#if LLVM_VERSION_GE(4, 0)
|
||||
Module *Dst = unwrap(DstRef);
|
||||
std::unique_ptr<Module> Src(unwrap(SrcRef));
|
||||
|
||||
if (Linker::linkModules(*Dst, std::move(Src))) {
|
||||
LLVMRustSetLastError("failed to link modules");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
#else
|
||||
LLVMRustSetLastError("can't link parsed modules on this LLVM");
|
||||
return false;
|
||||
#endif
|
||||
}
|
||||
|
||||
// Note that the two following functions look quite similar to the
|
||||
// LLVMGetSectionName function. Sadly, it appears that this function only
|
||||
// returns a char* pointer, which isn't guaranteed to be null-terminated. The
|
||||
|
@ -981,7 +958,6 @@ extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
|
|||
}
|
||||
|
||||
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
|
||||
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(DebugLoc, LLVMDebugLocRef)
|
||||
|
||||
extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
|
||||
RawRustStringOstream OS(Str);
|
||||
|
@ -1130,13 +1106,6 @@ extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
|
|||
report_fatal_error("Unhandled TypeID.");
|
||||
}
|
||||
|
||||
extern "C" void LLVMRustWriteDebugLocToString(LLVMContextRef C,
|
||||
LLVMDebugLocRef DL,
|
||||
RustStringRef Str) {
|
||||
RawRustStringOstream OS(Str);
|
||||
unwrap(DL)->print(OS);
|
||||
}
|
||||
|
||||
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
|
||||
|
||||
extern "C" void LLVMRustSetInlineAsmDiagnosticHandler(
|
||||
|
|
|
@ -103,9 +103,7 @@ enum LLVMRustAttribute {
|
|||
|
||||
typedef struct OpaqueRustString *RustStringRef;
|
||||
typedef struct LLVMOpaqueTwine *LLVMTwineRef;
|
||||
typedef struct LLVMOpaqueDebugLoc *LLVMDebugLocRef;
|
||||
typedef struct LLVMOpaqueSMDiagnostic *LLVMSMDiagnosticRef;
|
||||
typedef struct LLVMOpaqueRustJITMemoryManager *LLVMRustJITMemoryManagerRef;
|
||||
|
||||
extern "C" void LLVMRustStringWriteImpl(RustStringRef Str, const char *Ptr,
|
||||
size_t Size);
|
||||
|
|
20
src/test/rustdoc/issue-47038.rs
Normal file
20
src/test/rustdoc/issue-47038.rs
Normal file
|
@ -0,0 +1,20 @@
|
|||
// 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.
|
||||
|
||||
#![feature(decl_macro)]
|
||||
|
||||
#![crate_name = "foo"]
|
||||
|
||||
use std::vec;
|
||||
|
||||
// @has 'foo/index.html'
|
||||
// @!has - '//*[@id="macros"]' 'Macros'
|
||||
// @!has - '//a/@href' 'macro.vec.html'
|
||||
// @!has 'foo/macro.vec.html'
|
18
src/test/rustdoc/issue-47197-blank-line-in-doc-block.rs
Normal file
18
src/test/rustdoc/issue-47197-blank-line-in-doc-block.rs
Normal file
|
@ -0,0 +1,18 @@
|
|||
// Copyright 2017 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.
|
||||
|
||||
// @has issue_47197_blank_line_in_doc_block/fn.whose_woods_these_are_i_think_i_know.html
|
||||
|
||||
/**
|
||||
* snow
|
||||
|
||||
* ice
|
||||
*/
|
||||
pub fn whose_woods_these_are_i_think_i_know() {}
|
|
@ -158,13 +158,6 @@ fn check(cache: &mut Cache,
|
|||
file.ends_with("sync/struct.RwLock.html") {
|
||||
return None;
|
||||
}
|
||||
// FIXME(#47038)
|
||||
if file.ends_with("deriving/generic/index.html") ||
|
||||
file.ends_with("deriving/generic/macro.vec.html") ||
|
||||
file.ends_with("deriving/custom/macro.panic.html") ||
|
||||
file.ends_with("proc_macro_impl/macro.panic.html") {
|
||||
return None;
|
||||
}
|
||||
|
||||
let res = load_file(cache, root, file, SkipRedirect);
|
||||
let (pretty_file, contents) = match res {
|
||||
|
|
Loading…
Reference in a new issue