From 30de5b879f62dbc681bc6e6f9afd2fb2c0205b22 Mon Sep 17 00:00:00 2001 From: Joshua Nelson Date: Sat, 3 Oct 2020 12:12:31 -0400 Subject: [PATCH] [WIP] Don't re-export `rustc_ast` items in `rustc_hir` - BorrowKind - ImplPolarity - IsAuto - CaptureBy - Movability - Mutability While working on this I realized that there are many different enums named `BorrowKind`, so it should really keep the prefix and just change it from `hir::` to `ast::`. --- compiler/rustc_ast_lowering/src/expr.rs | 6 +-- compiler/rustc_codegen_llvm/src/intrinsic.rs | 3 +- .../src/debuginfo/type_names.rs | 5 ++- compiler/rustc_data_structures/src/lib.rs | 1 + compiler/rustc_hir/src/hir.rs | 4 +- compiler/rustc_hir/src/pat_util.rs | 7 ++-- compiler/rustc_hir_pretty/src/lib.rs | 37 ++++++++++--------- .../src/infer/error_reporting/mod.rs | 3 +- compiler/rustc_lint/src/builtin.rs | 2 +- compiler/rustc_lint/src/internal.rs | 4 +- compiler/rustc_metadata/src/rmeta/decoder.rs | 7 ++-- compiler/rustc_metadata/src/rmeta/encoder.rs | 9 +++-- compiler/rustc_middle/src/mir/mod.rs | 4 +- compiler/rustc_middle/src/mir/tcx.rs | 10 ++--- compiler/rustc_middle/src/query/mod.rs | 3 +- compiler/rustc_middle/src/ty/adjustment.rs | 15 ++++---- compiler/rustc_middle/src/ty/binding.rs | 2 +- compiler/rustc_middle/src/ty/context.rs | 11 +++--- compiler/rustc_middle/src/ty/error.rs | 5 ++- compiler/rustc_middle/src/ty/layout.rs | 6 +-- compiler/rustc_middle/src/ty/mod.rs | 15 ++++---- compiler/rustc_middle/src/ty/print/pretty.rs | 9 +++-- compiler/rustc_middle/src/ty/query/mod.rs | 1 + compiler/rustc_middle/src/ty/relate.rs | 11 +++--- .../rustc_middle/src/ty/structural_impls.rs | 2 +- compiler/rustc_middle/src/ty/sty.rs | 13 ++++--- compiler/rustc_middle/src/ty/util.rs | 7 ++-- .../diagnostics/conflict_errors.rs | 3 +- .../diagnostics/mutability_errors.rs | 6 +-- compiler/rustc_mir/src/borrow_check/mod.rs | 13 ++++--- .../rustc_mir/src/borrow_check/place_ext.rs | 4 +- .../src/borrow_check/places_conflict.rs | 5 ++- .../rustc_mir/src/borrow_check/prefixes.rs | 6 +-- .../src/borrow_check/type_check/mod.rs | 12 +++--- .../src/borrow_check/universal_regions.rs | 3 +- compiler/rustc_mir/src/const_eval/mod.rs | 2 +- compiler/rustc_mir/src/interpret/intern.rs | 4 +- compiler/rustc_mir/src/shim.rs | 4 +- .../src/transform/check_consts/validation.rs | 6 +-- compiler/rustc_mir/src/transform/generator.rs | 4 +- .../rustc_mir/src/transform/instcombine.rs | 2 +- compiler/rustc_mir/src/transform/nrvo.rs | 2 +- .../rustc_mir/src/util/elaborate_drops.rs | 4 +- .../rustc_mir_build/src/build/expr/into.rs | 4 +- compiler/rustc_mir_build/src/build/mod.rs | 2 +- compiler/rustc_mir_build/src/thir/cx/expr.rs | 16 ++++---- compiler/rustc_mir_build/src/thir/mod.rs | 6 +-- .../src/thir/pattern/check_match.rs | 2 +- .../rustc_mir_build/src/thir/pattern/mod.rs | 4 +- compiler/rustc_passes/src/loops.rs | 3 +- compiler/rustc_save_analysis/src/lib.rs | 7 ++-- compiler/rustc_save_analysis/src/sig.rs | 14 +++---- compiler/rustc_symbol_mangling/src/v0.rs | 10 ++--- .../src/traits/error_reporting/suggestions.rs | 7 ++-- .../rustc_trait_selection/src/traits/misc.rs | 3 +- .../src/traits/select/candidate_assembly.rs | 5 ++- .../src/traits/select/mod.rs | 5 ++- compiler/rustc_typeck/src/check/_match.rs | 5 ++- compiler/rustc_typeck/src/check/callee.rs | 5 ++- compiler/rustc_typeck/src/check/cast.rs | 3 +- compiler/rustc_typeck/src/check/check.rs | 5 ++- compiler/rustc_typeck/src/check/closure.rs | 7 ++-- compiler/rustc_typeck/src/check/coercion.rs | 29 ++++++++------- .../rustc_typeck/src/check/compare_method.rs | 5 ++- compiler/rustc_typeck/src/check/demand.rs | 25 +++++++------ compiler/rustc_typeck/src/check/expr.rs | 9 +++-- compiler/rustc_typeck/src/check/intrinsic.rs | 23 ++++++------ .../rustc_typeck/src/check/method/confirm.rs | 5 ++- .../rustc_typeck/src/check/method/probe.rs | 13 ++++--- compiler/rustc_typeck/src/check/mod.rs | 9 +++-- compiler/rustc_typeck/src/check/op.rs | 11 +++--- compiler/rustc_typeck/src/check/pat.rs | 11 +++--- compiler/rustc_typeck/src/check/place_op.rs | 9 +++-- compiler/rustc_typeck/src/check/regionck.rs | 13 ++++--- compiler/rustc_typeck/src/check/upvar.rs | 9 +++-- .../rustc_typeck/src/coherence/builtin.rs | 3 +- .../src/coherence/inherent_impls.rs | 9 +++-- .../rustc_typeck/src/coherence/unsafety.rs | 17 +++++---- compiler/rustc_typeck/src/collect.rs | 12 +++--- .../rustc_typeck/src/variance/constraints.rs | 7 ++-- src/librustdoc/clean/inline.rs | 2 +- src/librustdoc/clean/mod.rs | 7 ++-- src/librustdoc/clean/types.rs | 2 +- src/librustdoc/doctree.rs | 7 ++-- src/librustdoc/html/format.rs | 11 +++--- src/librustdoc/html/render/mod.rs | 2 +- .../clippy/clippy_lints/src/bytecount.rs | 3 +- src/tools/clippy/clippy_lints/src/entry.rs | 3 +- src/tools/clippy/clippy_lints/src/eq_op.rs | 3 +- .../clippy/clippy_lints/src/explicit_write.rs | 3 +- src/tools/clippy/clippy_lints/src/format.rs | 3 +- .../clippy/clippy_lints/src/functions.rs | 5 ++- .../clippy/clippy_lints/src/infinite_iter.rs | 3 +- src/tools/clippy/clippy_lints/src/loops.rs | 5 ++- .../clippy/clippy_lints/src/manual_strip.rs | 3 +- .../clippy/clippy_lints/src/map_clone.rs | 2 +- .../clippy/clippy_lints/src/map_err_ignore.rs | 3 +- src/tools/clippy/clippy_lints/src/matches.rs | 3 +- .../clippy_lints/src/mem_discriminant.rs | 3 +- .../clippy/clippy_lints/src/mem_replace.rs | 3 +- .../clippy/clippy_lints/src/methods/mod.rs | 25 +++++++------ src/tools/clippy/clippy_lints/src/misc.rs | 3 +- src/tools/clippy/clippy_lints/src/mut_key.rs | 3 +- src/tools/clippy/clippy_lints/src/mut_mut.rs | 12 +++--- .../clippy/clippy_lints/src/mut_reference.rs | 3 +- .../src/mutable_debug_assertion.rs | 3 +- .../clippy_lints/src/needless_borrow.rs | 3 +- .../clippy_lints/src/needless_borrowed_ref.rs | 3 +- .../clippy_lints/src/option_if_let_else.rs | 3 +- .../clippy_lints/src/pattern_type_mismatch.rs | 3 +- src/tools/clippy/clippy_lints/src/ptr.rs | 3 +- src/tools/clippy/clippy_lints/src/regex.rs | 3 +- .../clippy/clippy_lints/src/transmute.rs | 3 +- .../src/trivially_copy_pass_by_ref.rs | 3 +- src/tools/clippy/clippy_lints/src/types.rs | 4 +- .../clippy_lints/src/unnecessary_sort_by.rs | 3 +- .../clippy_lints/src/utils/hir_utils.rs | 3 +- .../clippy_lints/src/utils/internal_lints.rs | 4 +- .../src/utils/qualify_min_const_fn.rs | 2 +- src/tools/clippy/clippy_lints/src/vec.rs | 3 +- 120 files changed, 434 insertions(+), 348 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs index c97f80cf09ba1..1eb24a2119bed 100644 --- a/compiler/rustc_ast_lowering/src/expr.rs +++ b/compiler/rustc_ast_lowering/src/expr.rs @@ -545,7 +545,7 @@ impl<'hir> LoweringContext<'_, 'hir> { decl, body_id, span, - Some(hir::Movability::Static), + Some(Movability::Static), ); let generator = hir::Expr { hir_id: self.lower_node_id(closure_node_id), @@ -751,7 +751,7 @@ impl<'hir> LoweringContext<'_, 'hir> { fn_decl_span: Span, generator_kind: Option, movability: Movability, - ) -> Option { + ) -> Option { match generator_kind { Some(hir::GeneratorKind::Gen) => { if decl.inputs.len() > 1 { @@ -1638,7 +1638,7 @@ impl<'hir> LoweringContext<'_, 'hir> { fn expr_mut_addr_of(&mut self, span: Span, e: &'hir hir::Expr<'hir>) -> hir::Expr<'hir> { self.expr( span, - hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, e), + hir::ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, e), ThinVec::new(), ) } diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs index 7f5b09eac4f9e..59b0fe60dc705 100644 --- a/compiler/rustc_codegen_llvm/src/intrinsic.rs +++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs @@ -7,6 +7,7 @@ use crate::type_of::LayoutLlvmExt; use crate::va_arg::emit_va_arg; use crate::value::Value; +use rustc_ast::Mutability; use rustc_codegen_ssa::base::{compare_simd_types, wants_msvc_seh}; use rustc_codegen_ssa::common::span_invalid_monomorphization_error; use rustc_codegen_ssa::common::{IntPredicate, TypeKind}; @@ -1332,7 +1333,7 @@ fn generic_simd_intrinsic( // The second argument must be a simd vector with an element type that's a pointer // to the element type of the first argument let (pointer_count, underlying_ty) = match arg_tys[1].simd_type(tcx).kind() { - ty::RawPtr(p) if p.ty == in_elem && p.mutbl == hir::Mutability::Mut => { + ty::RawPtr(p) if p.ty == in_elem && p.mutbl == Mutability::Mut => { (ptr_count(arg_tys[1].simd_type(tcx)), non_ptr(arg_tys[1].simd_type(tcx))) } _ => { diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs index 45ecb793387d0..1fa9c900bc608 100644 --- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs +++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs @@ -1,6 +1,7 @@ // Type Names for Debug Info. use rustc_data_structures::fx::FxHashSet; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_middle::ty::{self, subst::SubstsRef, Ty, TyCtxt}; @@ -75,8 +76,8 @@ pub fn push_debuginfo_type_name<'tcx>( output.push('*'); } match mutbl { - hir::Mutability::Not => output.push_str("const "), - hir::Mutability::Mut => output.push_str("mut "), + Mutability::Not => output.push_str("const "), + Mutability::Mut => output.push_str("mut "), } push_debuginfo_type_name(tcx, inner_type, true, output, visited); diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs index 90b0f25475181..f91bcbedb3c4d 100644 --- a/compiler/rustc_data_structures/src/lib.rs +++ b/compiler/rustc_data_structures/src/lib.rs @@ -29,6 +29,7 @@ #![feature(min_const_generics)] #![feature(once_cell)] #![allow(rustc::default_hash_types)] +#![allow(rustc::pub_cross_crate_reexport)] #[macro_use] extern crate tracing; diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 636f67a77c890..342cca81a4a5c 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -7,8 +7,8 @@ use rustc_ast::node_id::NodeMap; use rustc_ast::util::parser::ExprPrecedence; use rustc_ast::{self as ast, CrateSugar, LlvmAsmDialect}; use rustc_ast::{AttrVec, Attribute, FloatTy, IntTy, Label, LitKind, StrStyle, UintTy}; -pub use rustc_ast::{BorrowKind, ImplPolarity, IsAuto}; -pub use rustc_ast::{CaptureBy, Movability, Mutability}; +use rustc_ast::{BorrowKind, ImplPolarity, IsAuto}; +use rustc_ast::{CaptureBy, Movability, Mutability}; use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece}; use rustc_data_structures::sync::{par_for_each_in, Send, Sync}; use rustc_macros::HashStable_Generic; diff --git a/compiler/rustc_hir/src/pat_util.rs b/compiler/rustc_hir/src/pat_util.rs index 2f1b5da8e13a0..c8fc8fe267830 100644 --- a/compiler/rustc_hir/src/pat_util.rs +++ b/compiler/rustc_hir/src/pat_util.rs @@ -3,6 +3,7 @@ use crate::def_id::DefId; use crate::hir::{self, HirId, PatKind}; use rustc_span::symbol::Ident; use rustc_span::Span; +use rustc_ast::Mutability; use std::iter::{Enumerate, ExactSizeIterator}; @@ -179,14 +180,14 @@ impl hir::Pat<'_> { // // FIXME(tschottdorf): this is problematic as the HIR is being scraped, but // ref bindings are be implicit after #42640 (default match binding modes). See issue #44848. - pub fn contains_explicit_ref_binding(&self) -> Option { + pub fn contains_explicit_ref_binding(&self) -> Option { let mut result = None; self.each_binding(|annotation, _, _, _| match annotation { hir::BindingAnnotation::Ref => match result { - None | Some(hir::Mutability::Not) => result = Some(hir::Mutability::Not), + None | Some(Mutability::Not) => result = Some(Mutability::Not), _ => {} }, - hir::BindingAnnotation::RefMut => result = Some(hir::Mutability::Mut), + hir::BindingAnnotation::RefMut => result = Some(Mutability::Mut), _ => {} }); result diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index f6e4b1fb418bf..7c4c680eef39d 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -2,6 +2,7 @@ #![recursion_limit = "256"] use rustc_ast as ast; +use rustc_ast::{BorrowKind, CaptureBy, IsAuto, ImplPolarity, Mutability}; use rustc_ast::util::parser::{self, AssocOp, Fixity}; use rustc_ast_pretty::pp::Breaks::{Consistent, Inconsistent}; use rustc_ast_pretty::pp::{self, Breaks}; @@ -477,7 +478,7 @@ impl<'a> State<'a> { } hir::ForeignItemKind::Static(ref t, m) => { self.head(visibility_qualified(&item.vis, "static")); - if m == hir::Mutability::Mut { + if m == Mutability::Mut { self.word_space("mut"); } self.print_ident(item.ident); @@ -598,7 +599,7 @@ impl<'a> State<'a> { } hir::ItemKind::Static(ref ty, m, expr) => { self.head(visibility_qualified(&item.vis, "static")); - if m == hir::Mutability::Mut { + if m == Mutability::Mut { self.word_space("mut"); } self.print_ident(item.ident); @@ -719,7 +720,7 @@ impl<'a> State<'a> { self.word_nbsp("const"); } - if let hir::ImplPolarity::Negative(_) = polarity { + if let ImplPolarity::Negative(_) = polarity { self.s.word("!"); } @@ -1257,14 +1258,14 @@ impl<'a> State<'a> { fn print_expr_addr_of( &mut self, - kind: hir::BorrowKind, - mutability: hir::Mutability, + kind: BorrowKind, + mutability: Mutability, expr: &hir::Expr<'_>, ) { self.s.word("&"); match kind { - hir::BorrowKind::Ref => self.print_mutability(mutability, false), - hir::BorrowKind::Raw => { + BorrowKind::Ref => self.print_mutability(mutability, false), + BorrowKind::Raw => { self.word_nbsp("raw"); self.print_mutability(mutability, true); } @@ -1825,11 +1826,11 @@ impl<'a> State<'a> { match binding_mode { hir::BindingAnnotation::Ref => { self.word_nbsp("ref"); - self.print_mutability(hir::Mutability::Not, false); + self.print_mutability(Mutability::Not, false); } hir::BindingAnnotation::RefMut => { self.word_nbsp("ref"); - self.print_mutability(hir::Mutability::Mut, false); + self.print_mutability(Mutability::Mut, false); } hir::BindingAnnotation::Unannotated => {} hir::BindingAnnotation::Mutable => { @@ -2114,10 +2115,10 @@ impl<'a> State<'a> { } } - pub fn print_capture_clause(&mut self, capture_clause: hir::CaptureBy) { + pub fn print_capture_clause(&mut self, capture_clause: CaptureBy) { match capture_clause { - hir::CaptureBy::Value => self.word_space("move"), - hir::CaptureBy::Ref => {} + CaptureBy::Value => self.word_space("move"), + CaptureBy::Ref => {} } } @@ -2268,10 +2269,10 @@ impl<'a> State<'a> { } } - pub fn print_mutability(&mut self, mutbl: hir::Mutability, print_const: bool) { + pub fn print_mutability(&mut self, mutbl: Mutability, print_const: bool) { match mutbl { - hir::Mutability::Mut => self.word_nbsp("mut"), - hir::Mutability::Not => { + Mutability::Mut => self.word_nbsp("mut"), + Mutability::Not => { if print_const { self.word_nbsp("const") } @@ -2410,10 +2411,10 @@ impl<'a> State<'a> { } } - pub fn print_is_auto(&mut self, s: hir::IsAuto) { + pub fn print_is_auto(&mut self, s: IsAuto) { match s { - hir::IsAuto::Yes => self.word_nbsp("auto"), - hir::IsAuto::No => {} + IsAuto::Yes => self.word_nbsp("auto"), + IsAuto::No => {} } } } diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs index 795c5a64d26b7..bbc74751364b8 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs @@ -56,6 +56,7 @@ use crate::traits::{ IfExpressionCause, MatchExpressionArmCause, ObligationCause, ObligationCauseCode, }; +use rustc_ast::Mutability; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::{pluralize, struct_span_err}; use rustc_errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString}; @@ -1060,7 +1061,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { fn push_ty_ref<'tcx>( region: &ty::Region<'tcx>, ty: Ty<'tcx>, - mutbl: hir::Mutability, + mutbl: Mutability, s: &mut DiagnosticStyledString, ) { let mut r = region.to_string(); diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index abd899e8db4d3..335e0ddec581d 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -1168,7 +1168,7 @@ impl<'tcx> LateLintPass<'tcx> for MutableTransmutes { if let Some((&ty::Ref(_, _, from_mt), &ty::Ref(_, _, to_mt))) = get_transmute_from_to(cx, expr).map(|(ty1, ty2)| (ty1.kind(), ty2.kind())) { - if to_mt == hir::Mutability::Mut && from_mt == hir::Mutability::Not { + if to_mt == Mutability::Mut && from_mt == Mutability::Not { let msg = "mutating transmuted &mut T from &T may cause undefined behavior, \ consider instead using an UnsafeCell"; cx.struct_span_lint(MUTABLE_TRANSMUTES, expr.span, |lint| lint.build(msg).emit()); diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index c2d98b8e4ad37..8132de58e5b0f 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -2,11 +2,11 @@ //! Clippy. use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext}; -use rustc_ast::{Item, ItemKind}; +use rustc_ast::{Item, ItemKind, Mutability}; use rustc_data_structures::fx::FxHashMap; use rustc_errors::Applicability; use rustc_hir::def::Res; -use rustc_hir::{GenericArg, HirId, MutTy, Mutability, Path, PathSegment, QPath, Ty, TyKind}; +use rustc_hir::{GenericArg, HirId, MutTy, Path, PathSegment, QPath, Ty, TyKind}; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass}; use rustc_span::hygiene::{ExpnKind, MacroKind}; diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs index c31e941b3ffc6..e45811a81d84f 100644 --- a/compiler/rustc_metadata/src/rmeta/decoder.rs +++ b/compiler/rustc_metadata/src/rmeta/decoder.rs @@ -5,6 +5,7 @@ use crate::rmeta::table::{FixedSizeEncoding, Table}; use crate::rmeta::*; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_attr as attr; use rustc_data_structures::captures::Captures; use rustc_data_structures::fingerprint::{Fingerprint, FingerprintDecoder}; @@ -1517,10 +1518,10 @@ impl<'a, 'tcx> CrateMetadataRef<'a> { } } - fn static_mutability(&self, id: DefIndex) -> Option { + fn static_mutability(&self, id: DefIndex) -> Option { match self.kind(id) { - EntryKind::ImmStatic | EntryKind::ForeignImmStatic => Some(hir::Mutability::Not), - EntryKind::MutStatic | EntryKind::ForeignMutStatic => Some(hir::Mutability::Mut), + EntryKind::ImmStatic | EntryKind::ForeignImmStatic => Some(Mutability::Not), + EntryKind::MutStatic | EntryKind::ForeignMutStatic => Some(Mutability::Mut), _ => None, } } diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 757156e5a7d27..b686a42be6d31 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -2,6 +2,7 @@ use crate::rmeta::table::{FixedSizeEncoding, TableBuilder}; use crate::rmeta::*; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_data_structures::fingerprint::{Fingerprint, FingerprintEncoder}; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet}; use rustc_data_structures::stable_hasher::StableHasher; @@ -1228,8 +1229,8 @@ impl EncodeContext<'a, 'tcx> { self.encode_ident_span(def_id, item.ident); record!(self.tables.kind[def_id] <- match item.kind { - hir::ItemKind::Static(_, hir::Mutability::Mut, _) => EntryKind::MutStatic, - hir::ItemKind::Static(_, hir::Mutability::Not, _) => EntryKind::ImmStatic, + hir::ItemKind::Static(_, Mutability::Mut, _) => EntryKind::MutStatic, + hir::ItemKind::Static(_, Mutability::Not, _) => EntryKind::ImmStatic, hir::ItemKind::Const(_, body_id) => { let qualifs = self.tcx.at(item.span).mir_const_qualif(def_id); EntryKind::Const( @@ -1740,8 +1741,8 @@ impl EncodeContext<'a, 'tcx> { }; EntryKind::ForeignFn(self.lazy(data)) } - hir::ForeignItemKind::Static(_, hir::Mutability::Mut) => EntryKind::ForeignMutStatic, - hir::ForeignItemKind::Static(_, hir::Mutability::Not) => EntryKind::ForeignImmStatic, + hir::ForeignItemKind::Static(_, Mutability::Mut) => EntryKind::ForeignMutStatic, + hir::ForeignItemKind::Static(_, Mutability::Not) => EntryKind::ForeignImmStatic, hir::ForeignItemKind::Type => EntryKind::ForeignType, }); record!(self.tables.visibility[def_id] <- diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs index fee24f0bae8ca..707b144e84a16 100644 --- a/compiler/rustc_middle/src/mir/mod.rs +++ b/compiler/rustc_middle/src/mir/mod.rs @@ -20,7 +20,7 @@ use rustc_hir::{self, GeneratorKind}; use rustc_target::abi::VariantIdx; use polonius_engine::Atom; -pub use rustc_ast::Mutability; +pub use rustc_ast::{Movability, Mutability}; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::graph::dominators::{dominators, Dominators}; use rustc_data_structures::graph::{self, GraphSuccessors}; @@ -2084,7 +2084,7 @@ pub enum AggregateKind<'tcx> { Adt(&'tcx AdtDef, VariantIdx, SubstsRef<'tcx>, Option, Option), Closure(DefId, SubstsRef<'tcx>), - Generator(DefId, SubstsRef<'tcx>, hir::Movability), + Generator(DefId, SubstsRef<'tcx>, Movability), } #[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] diff --git a/compiler/rustc_middle/src/mir/tcx.rs b/compiler/rustc_middle/src/mir/tcx.rs index b9e4f6fb12eb1..10c6b7e3d7bcb 100644 --- a/compiler/rustc_middle/src/mir/tcx.rs +++ b/compiler/rustc_middle/src/mir/tcx.rs @@ -245,19 +245,19 @@ impl<'tcx> BinOp { } impl BorrowKind { - pub fn to_mutbl_lossy(self) -> hir::Mutability { + pub fn to_mutbl_lossy(self) -> Mutability { match self { - BorrowKind::Mut { .. } => hir::Mutability::Mut, - BorrowKind::Shared => hir::Mutability::Not, + BorrowKind::Mut { .. } => Mutability::Mut, + BorrowKind::Shared => Mutability::Not, // We have no type corresponding to a unique imm borrow, so // use `&mut`. It gives all the capabilities of an `&uniq` // and hence is a safe "over approximation". - BorrowKind::Unique => hir::Mutability::Mut, + BorrowKind::Unique => Mutability::Mut, // We have no type corresponding to a shallow borrow, so use // `&` as an approximation. - BorrowKind::Shallow => hir::Mutability::Not, + BorrowKind::Shallow => Mutability::Not, } } } diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs index d5b99ea4d288d..c86a11bf6a760 100644 --- a/compiler/rustc_middle/src/query/mod.rs +++ b/compiler/rustc_middle/src/query/mod.rs @@ -9,6 +9,7 @@ use crate::traits::query::{ use crate::ty::query::queries; use crate::ty::subst::{GenericArg, SubstsRef}; use crate::ty::{self, ParamEnvAnd, Ty, TyCtxt}; +use rustc_ast::Mutability; use rustc_hir::def_id::{CrateNum, DefId, LocalDefId}; use rustc_query_system::query::QueryDescription; @@ -463,7 +464,7 @@ rustc_queries! { } /// Returns `Some(mutability)` if the node pointed to by `def_id` is a static item. - query static_mutability(def_id: DefId) -> Option { + query static_mutability(def_id: DefId) -> Option { desc { |tcx| "looking up static mutability of `{}`", tcx.def_path_str(def_id) } } diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs index 46ef5ff7dd8c5..f51a3f4a4e3d4 100644 --- a/compiler/rustc_middle/src/ty/adjustment.rs +++ b/compiler/rustc_middle/src/ty/adjustment.rs @@ -1,5 +1,6 @@ use crate::ty::subst::SubstsRef; use crate::ty::{self, Ty, TyCtxt}; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_hir::lang_items::LangItem; @@ -113,7 +114,7 @@ pub enum Adjust<'tcx> { #[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct OverloadedDeref<'tcx> { pub region: ty::Region<'tcx>, - pub mutbl: hir::Mutability, + pub mutbl: Mutability, /// The `Span` associated with the field access or method call /// that triggered this overloaded deref. pub span: Span, @@ -122,8 +123,8 @@ pub struct OverloadedDeref<'tcx> { impl<'tcx> OverloadedDeref<'tcx> { pub fn method_call(&self, tcx: TyCtxt<'tcx>, source: Ty<'tcx>) -> (DefId, SubstsRef<'tcx>) { let trait_def_id = match self.mutbl { - hir::Mutability::Not => tcx.require_lang_item(LangItem::Deref, None), - hir::Mutability::Mut => tcx.require_lang_item(LangItem::DerefMut, None), + Mutability::Not => tcx.require_lang_item(LangItem::Deref, None), + Mutability::Mut => tcx.require_lang_item(LangItem::DerefMut, None), }; let method_def_id = tcx .associated_items(trait_def_id) @@ -159,11 +160,11 @@ pub enum AutoBorrowMutability { Not, } -impl From for hir::Mutability { +impl From for Mutability { fn from(m: AutoBorrowMutability) -> Self { match m { - AutoBorrowMutability::Mut { .. } => hir::Mutability::Mut, - AutoBorrowMutability::Not => hir::Mutability::Not, + AutoBorrowMutability::Mut { .. } => Mutability::Mut, + AutoBorrowMutability::Not => Mutability::Not, } } } @@ -174,7 +175,7 @@ pub enum AutoBorrow<'tcx> { Ref(ty::Region<'tcx>, AutoBorrowMutability), /// Converts from T to *T. - RawPtr(hir::Mutability), + RawPtr(Mutability), } /// Information for `CoerceUnsized` impls, storing information we diff --git a/compiler/rustc_middle/src/ty/binding.rs b/compiler/rustc_middle/src/ty/binding.rs index 3237147c8ba2f..716961ccb81e6 100644 --- a/compiler/rustc_middle/src/ty/binding.rs +++ b/compiler/rustc_middle/src/ty/binding.rs @@ -1,6 +1,6 @@ use rustc_hir::BindingAnnotation; use rustc_hir::BindingAnnotation::*; -use rustc_hir::Mutability; +use rustc_ast::Mutability; #[derive(Clone, PartialEq, TyEncodable, TyDecodable, Debug, Copy, HashStable)] pub enum BindingMode { diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 22c3fd37be14d..89584049f4a16 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -25,6 +25,7 @@ use crate::ty::{ TyVid, TypeAndMut, }; use rustc_ast as ast; +use rustc_ast::{Movability, Mutability}; use rustc_ast::expand::allocator::AllocatorKind; use rustc_attr as attr; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -2215,22 +2216,22 @@ impl<'tcx> TyCtxt<'tcx> { #[inline] pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Mut }) + self.mk_ref(r, TypeAndMut { ty, mutbl: Mutability::Mut }) } #[inline] pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Not }) + self.mk_ref(r, TypeAndMut { ty, mutbl: Mutability::Not }) } #[inline] pub fn mk_mut_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Mut }) + self.mk_ptr(TypeAndMut { ty, mutbl: Mutability::Mut }) } #[inline] pub fn mk_imm_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> { - self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Not }) + self.mk_ptr(TypeAndMut { ty, mutbl: Mutability::Not }) } #[inline] @@ -2305,7 +2306,7 @@ impl<'tcx> TyCtxt<'tcx> { self, id: DefId, generator_substs: SubstsRef<'tcx>, - movability: hir::Movability, + movability: Movability, ) -> Ty<'tcx> { self.mk_ty(Generator(id, generator_substs, movability)) } diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs index 82d698b37ab1d..08ca6ad4c7efb 100644 --- a/compiler/rustc_middle/src/ty/error.rs +++ b/compiler/rustc_middle/src/ty/error.rs @@ -2,6 +2,7 @@ use crate::traits::{ObligationCause, ObligationCauseCode}; use crate::ty::diagnostics::suggest_constraining_type_param; use crate::ty::{self, BoundRegion, Region, Ty, TyCtxt}; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_errors::Applicability::{MachineApplicable, MaybeIncorrect}; use rustc_errors::{pluralize, DiagnosticBuilder}; use rustc_hir as hir; @@ -249,7 +250,7 @@ impl<'tcx> ty::TyS<'tcx> { } else { // Unknown type name, it's long or has type arguments match mutbl { - hir::Mutability::Mut => "mutable reference", + Mutability::Mut => "mutable reference", _ => "reference", } .into() @@ -301,7 +302,7 @@ impl<'tcx> ty::TyS<'tcx> { ty::Slice(_) => "slice".into(), ty::RawPtr(_) => "raw pointer".into(), ty::Ref(.., mutbl) => match mutbl { - hir::Mutability::Mut => "mutable reference", + Mutability::Mut => "mutable reference", _ => "reference", } .into(), diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs index ee669ed228969..eb0fd63ea5c45 100644 --- a/compiler/rustc_middle/src/ty/layout.rs +++ b/compiler/rustc_middle/src/ty/layout.rs @@ -4,7 +4,7 @@ use crate::mir::{GeneratorLayout, GeneratorSavedLocal}; use crate::ty::subst::Subst; use crate::ty::{self, subst::SubstsRef, ReprOptions, Ty, TyCtxt, TypeFoldable}; -use rustc_ast::{self as ast, IntTy, UintTy}; +use rustc_ast::{self as ast, IntTy, UintTy, Mutability}; use rustc_attr as attr; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_hir as hir; @@ -2176,14 +2176,14 @@ where let tcx = cx.tcx(); let is_freeze = ty.is_freeze(tcx.at(DUMMY_SP), cx.param_env()); let kind = match mt { - hir::Mutability::Not => { + Mutability::Not => { if is_freeze { PointerKind::Frozen } else { PointerKind::Shared } } - hir::Mutability::Mut => { + Mutability::Mut => { // Previously we would only emit noalias annotations for LLVM >= 6 or in // panic=abort mode. That was deemed right, as prior versions had many bugs // in conjunction with unwinding, but later versions didn’t seem to have diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs index b7530c077ccd1..3bb60bfc00db0 100644 --- a/compiler/rustc_middle/src/ty/mod.rs +++ b/compiler/rustc_middle/src/ty/mod.rs @@ -18,6 +18,7 @@ use crate::ty; use crate::ty::subst::{GenericArg, InternalSubsts, Subst, SubstsRef}; use crate::ty::util::{Discr, IntTypeExt}; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_attr as attr; use rustc_data_structures::captures::Captures; use rustc_data_structures::fingerprint::Fingerprint; @@ -2704,10 +2705,10 @@ impl<'tcx> ClosureKind { } impl BorrowKind { - pub fn from_mutbl(m: hir::Mutability) -> BorrowKind { + pub fn from_mutbl(m: Mutability) -> BorrowKind { match m { - hir::Mutability::Mut => MutBorrow, - hir::Mutability::Not => ImmBorrow, + Mutability::Mut => MutBorrow, + Mutability::Not => ImmBorrow, } } @@ -2715,15 +2716,15 @@ impl BorrowKind { /// kind. Because borrow kinds are richer than mutabilities, we sometimes have to pick a /// mutability that is stronger than necessary so that it at least *would permit* the borrow in /// question. - pub fn to_mutbl_lossy(self) -> hir::Mutability { + pub fn to_mutbl_lossy(self) -> Mutability { match self { - MutBorrow => hir::Mutability::Mut, - ImmBorrow => hir::Mutability::Not, + MutBorrow => Mutability::Mut, + ImmBorrow => Mutability::Not, // We have no type corresponding to a unique imm borrow, so // use `&mut`. It gives all the capabilities of an `&uniq` // and hence is a safe "over approximation". - UniqueImmBorrow => hir::Mutability::Mut, + UniqueImmBorrow => Mutability::Mut, } } diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index 7b5cf681f38fb..548858bf50d13 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -6,6 +6,7 @@ use crate::ty::{self, ConstInt, DefIdTree, ParamConst, Ty, TyCtxt, TypeFoldable} use rustc_apfloat::ieee::{Double, Single}; use rustc_apfloat::Float; use rustc_ast as ast; +use rustc_ast::{Movability, Mutability}; use rustc_attr::{SignedInt, UnsignedInt}; use rustc_data_structures::fx::FxHashMap; use rustc_hir as hir; @@ -518,8 +519,8 @@ pub trait PrettyPrinter<'tcx>: p!(write( "*{} ", match tm.mutbl { - hir::Mutability::Mut => "mut", - hir::Mutability::Not => "const", + Mutability::Mut => "mut", + Mutability::Not => "const", } )); p!(print(tm.ty)) @@ -643,8 +644,8 @@ pub trait PrettyPrinter<'tcx>: ty::Generator(did, substs, movability) => { p!(write("[")); match movability { - hir::Movability::Movable => {} - hir::Movability::Static => p!(write("static ")), + Movability::Movable => {} + Movability::Static => p!(write("static ")), } if !self.tcx().sess.verbose() { diff --git a/compiler/rustc_middle/src/ty/query/mod.rs b/compiler/rustc_middle/src/ty/query/mod.rs index d3a7412ef14e7..bdcde9a67f3cd 100644 --- a/compiler/rustc_middle/src/ty/query/mod.rs +++ b/compiler/rustc_middle/src/ty/query/mod.rs @@ -32,6 +32,7 @@ use crate::ty::steal::Steal; use crate::ty::subst::{GenericArg, SubstsRef}; use crate::ty::util::AlwaysRequiresDrop; use crate::ty::{self, AdtSizedConstraint, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt}; +use rustc_ast::Mutability; use rustc_data_structures::fingerprint::Fingerprint; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap}; use rustc_data_structures::profiling::ProfileCategory::*; diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs index c4df0bba726cb..ac9b6f5b7e12e 100644 --- a/compiler/rustc_middle/src/ty/relate.rs +++ b/compiler/rustc_middle/src/ty/relate.rs @@ -8,7 +8,8 @@ use crate::mir::interpret::{get_slice_bytes, ConstValue}; use crate::ty::error::{ExpectedFound, TypeError}; use crate::ty::subst::{GenericArg, GenericArgKind, SubstsRef}; use crate::ty::{self, Ty, TyCtxt, TypeFoldable}; -use rustc_hir as ast; +use rustc_ast as ast; +use rustc_hir::Unsafety; use rustc_hir::def_id::DefId; use rustc_span::DUMMY_SP; use rustc_target::spec::abi; @@ -193,12 +194,12 @@ impl<'tcx> Relate<'tcx> for ty::FnSig<'tcx> { } } -impl<'tcx> Relate<'tcx> for ast::Unsafety { +impl<'tcx> Relate<'tcx> for Unsafety { fn relate>( relation: &mut R, - a: ast::Unsafety, - b: ast::Unsafety, - ) -> RelateResult<'tcx, ast::Unsafety> { + a: Unsafety, + b: Unsafety, + ) -> RelateResult<'tcx, Unsafety> { if a != b { Err(TypeError::UnsafetyMismatch(expected_found(relation, a, b))) } else { diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs index 597ceac9386a0..b4eba8c1a5d74 100644 --- a/compiler/rustc_middle/src/ty/structural_impls.rs +++ b/compiler/rustc_middle/src/ty/structural_impls.rs @@ -286,6 +286,7 @@ CloneTypeFoldableAndLiftImpls! { ::rustc_ast::InlineAsmOptions, ::rustc_ast::InlineAsmTemplatePiece, ::rustc_ast::NodeId, + ::rustc_ast::Mutability, ::rustc_span::symbol::Symbol, ::rustc_hir::def::Res, ::rustc_hir::def_id::DefId, @@ -293,7 +294,6 @@ CloneTypeFoldableAndLiftImpls! { ::rustc_hir::HirId, ::rustc_hir::LlvmInlineAsmInner, ::rustc_hir::MatchSource, - ::rustc_hir::Mutability, ::rustc_hir::Unsafety, ::rustc_target::asm::InlineAsmRegOrRegClass, ::rustc_target::spec::abi::Abi, diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs index 724ec101b23b7..b539b5df2cb2c 100644 --- a/compiler/rustc_middle/src/ty/sty.rs +++ b/compiler/rustc_middle/src/ty/sty.rs @@ -13,6 +13,7 @@ use crate::ty::{ use crate::ty::{DelaySpanBugEmitted, List, ParamEnv, TyS}; use polonius_engine::Atom; use rustc_ast as ast; +use rustc_ast::{Movability, Mutability}; use rustc_data_structures::captures::Captures; use rustc_hir as hir; use rustc_hir::def_id::DefId; @@ -31,7 +32,7 @@ use ty::util::IntTypeExt; #[derive(HashStable, TypeFoldable, Lift)] pub struct TypeAndMut<'tcx> { pub ty: Ty<'tcx>, - pub mutbl: hir::Mutability, + pub mutbl: Mutability, } #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, TyEncodable, TyDecodable, Copy)] @@ -127,7 +128,7 @@ pub enum TyKind<'tcx> { /// A reference; a pointer with an associated lifetime. Written as /// `&'a mut T` or `&'a T`. - Ref(Region<'tcx>, Ty<'tcx>, hir::Mutability), + Ref(Region<'tcx>, Ty<'tcx>, Mutability), /// The anonymous type of a function declaration/definition. Each /// function has a unique type, which is output (for a function @@ -160,7 +161,7 @@ pub enum TyKind<'tcx> { /// The anonymous type of a generator. Used to represent the type of /// `|a| yield a`. - Generator(DefId, SubstsRef<'tcx>, hir::Movability), + Generator(DefId, SubstsRef<'tcx>, Movability), /// A type representin the types stored inside a generator. /// This should only appear in GeneratorInteriors. @@ -1949,8 +1950,8 @@ impl<'tcx> TyS<'tcx> { #[inline] pub fn is_mutable_ptr(&self) -> bool { match self.kind() { - RawPtr(TypeAndMut { mutbl: hir::Mutability::Mut, .. }) - | Ref(_, _, hir::Mutability::Mut) => true, + RawPtr(TypeAndMut { mutbl: Mutability::Mut, .. }) + | Ref(_, _, Mutability::Mut) => true, _ => false, } } @@ -2123,7 +2124,7 @@ impl<'tcx> TyS<'tcx> { pub fn builtin_deref(&self, explicit: bool) -> Option> { match self.kind() { Adt(def, _) if def.is_box() => { - Some(TypeAndMut { ty: self.boxed_ty(), mutbl: hir::Mutability::Not }) + Some(TypeAndMut { ty: self.boxed_ty(), mutbl: Mutability::Not }) } Ref(_, ty, mutbl) => Some(TypeAndMut { ty, mutbl: *mutbl }), RawPtr(mt) if explicit => Some(*mt), diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs index 4127b6535bca6..fea014b8f1854 100644 --- a/compiler/rustc_middle/src/ty/util.rs +++ b/compiler/rustc_middle/src/ty/util.rs @@ -11,6 +11,7 @@ use crate::ty::TyKind::*; use crate::ty::{self, DefIdTree, GenericParamDefKind, List, Ty, TyCtxt, TypeFoldable}; use rustc_apfloat::Float as _; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_attr::{self as attr, SignedInt, UnsignedInt}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; @@ -535,7 +536,7 @@ impl<'tcx> TyCtxt<'tcx> { /// Returns `true` if the node pointed to by `def_id` is a mutable `static` item. pub fn is_mutable_static(self, def_id: DefId) -> bool { - self.static_mutability(def_id) == Some(hir::Mutability::Mut) + self.static_mutability(def_id) == Some(Mutability::Mut) } /// Get the type of the pointer to the static that we use in MIR. @@ -1031,8 +1032,8 @@ impl<'tcx> ty::TyS<'tcx> { pub enum ExplicitSelf<'tcx> { ByValue, - ByReference(ty::Region<'tcx>, hir::Mutability), - ByRawPointer(hir::Mutability), + ByReference(ty::Region<'tcx>, Mutability), + ByRawPointer(Mutability), ByBox, Other, } diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs index 11122b195c0c4..f498e5163b26f 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/conflict_errors.rs @@ -1,4 +1,5 @@ use either::Either; +use rustc_ast::Mutability; use rustc_data_structures::fx::FxHashSet; use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_hir as hir; @@ -311,7 +312,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { let ty = place.ty(self.body, self.infcx.tcx).ty; if is_loop_move { - if let ty::Ref(_, _, hir::Mutability::Mut) = ty.kind() { + if let ty::Ref(_, _, Mutability::Mut) = ty.kind() { // We have a `&mut` ref, we need to reborrow on each iteration (#62112). err.span_suggestion_verbose( span.shrink_to_lo(), diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs index d4cdf02104ace..fe85c2372a41a 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/mutability_errors.rs @@ -230,7 +230,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { // Otherwise, check if the name is the self kewyord - in which case // we have an explicit self. Do the same thing in this case and check // for a `self: &mut Self` to suggest removing the `&mut`. - if let ty::Ref(_, _, hir::Mutability::Mut) = local_decl.ty.kind() { + if let ty::Ref(_, _, Mutability::Mut) = local_decl.ty.kind() { true } else { false @@ -658,7 +658,7 @@ fn suggest_ampmut<'tcx>( } let ty_mut = local_decl.ty.builtin_deref(true).unwrap(); - assert_eq!(ty_mut.mutbl, hir::Mutability::Not); + assert_eq!(ty_mut.mutbl, Mutability::Not); ( highlight_span, if local_decl.ty.is_region_ptr() { @@ -697,7 +697,7 @@ fn annotate_struct_field( if let hir::Node::Field(field) = node { if let hir::TyKind::Rptr( lifetime, - hir::MutTy { mutbl: hir::Mutability::Not, ref ty }, + hir::MutTy { mutbl: Mutability::Not, ref ty }, ) = field.ty.kind { // Get the snippets in two parts - the named lifetime (if there is one) and diff --git a/compiler/rustc_mir/src/borrow_check/mod.rs b/compiler/rustc_mir/src/borrow_check/mod.rs index e4237482f47fa..c8305414bde17 100644 --- a/compiler/rustc_mir/src/borrow_check/mod.rs +++ b/compiler/rustc_mir/src/borrow_check/mod.rs @@ -1,5 +1,6 @@ //! This query borrow-checks the MIR to (further) ensure it is not broken. +use rustc_ast::Movability; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::graph::dominators::Dominators; use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorReported}; @@ -173,7 +174,7 @@ fn do_mir_borrowck<'a, 'tcx>( mutability: Mutability::Not, }; let bm = *tables.pat_binding_modes().get(var_hir_id).expect("missing binding mode"); - if bm == ty::BindByValue(hir::Mutability::Mut) { + if bm == ty::BindByValue(Mutability::Mut) { upvar.mutability = Mutability::Mut; } upvar @@ -278,7 +279,7 @@ fn do_mir_borrowck<'a, 'tcx>( let movable_generator = match tcx.hir().get(id) { Node::Expr(&hir::Expr { - kind: hir::ExprKind::Closure(.., Some(hir::Movability::Static)), + kind: hir::ExprKind::Closure(.., Some(Movability::Static)), .. }) => false, _ => true, @@ -2217,10 +2218,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { ty::Ref(_, _, mutbl) => { match mutbl { // Shared borrowed data is never mutable - hir::Mutability::Not => Err(place), + Mutability::Not => Err(place), // Mutably borrowed data is mutable, but only if we have a // unique path to the `&mut` - hir::Mutability::Mut => { + Mutability::Mut => { let mode = match self.is_upvar_field_projection(place) { Some(field) if self.upvars[field.index()].by_ref => { is_local_mutation_allowed @@ -2238,10 +2239,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { ty::RawPtr(tnm) => { match tnm.mutbl { // `*const` raw pointers are not mutable - hir::Mutability::Not => Err(place), + Mutability::Not => Err(place), // `*mut` raw pointers are always mutable, regardless of // context. The users have to check by themselves. - hir::Mutability::Mut => Ok(RootPlace { + Mutability::Mut => Ok(RootPlace { place_local: place.local, place_projection: place.projection, is_local_mutation_allowed, diff --git a/compiler/rustc_mir/src/borrow_check/place_ext.rs b/compiler/rustc_mir/src/borrow_check/place_ext.rs index 52fac3e53ee65..6911eb1e14667 100644 --- a/compiler/rustc_mir/src/borrow_check/place_ext.rs +++ b/compiler/rustc_mir/src/borrow_check/place_ext.rs @@ -50,7 +50,7 @@ impl<'tcx> PlaceExt<'tcx> for Place<'tcx> { if elem == ProjectionElem::Deref { let ty = Place::ty_from(self.local, proj_base, body, tcx).ty; match ty.kind() { - ty::Ref(_, _, hir::Mutability::Not) if i == 0 => { + ty::Ref(_, _, Mutability::Not) if i == 0 => { // For references to thread-local statics, we do need // to track the borrow. if body.local_decls[self.local].is_ref_to_thread_local() { @@ -58,7 +58,7 @@ impl<'tcx> PlaceExt<'tcx> for Place<'tcx> { } return true; } - ty::RawPtr(..) | ty::Ref(_, _, hir::Mutability::Not) => { + ty::RawPtr(..) | ty::Ref(_, _, Mutability::Not) => { // For both derefs of raw pointers and `&T` // references, the original path is `Copy` and // therefore not significant. In particular, diff --git a/compiler/rustc_mir/src/borrow_check/places_conflict.rs b/compiler/rustc_mir/src/borrow_check/places_conflict.rs index 02c7b7dc200c3..84dbe1b1ca901 100644 --- a/compiler/rustc_mir/src/borrow_check/places_conflict.rs +++ b/compiler/rustc_mir/src/borrow_check/places_conflict.rs @@ -1,6 +1,7 @@ use crate::borrow_check::ArtificialField; use crate::borrow_check::Overlap; use crate::borrow_check::{AccessDepth, Deep, Shallow}; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_middle::mir::{Body, BorrowKind, Local, Place, PlaceElem, PlaceRef, ProjectionElem}; use rustc_middle::ty::{self, TyCtxt}; @@ -231,11 +232,11 @@ fn place_components_conflict<'tcx>( debug!("borrow_conflicts_with_place: shallow access behind ptr"); return false; } - (ProjectionElem::Deref, ty::Ref(_, _, hir::Mutability::Not), _) => { + (ProjectionElem::Deref, ty::Ref(_, _, Mutability::Not), _) => { // Shouldn't be tracked bug!("Tracking borrow behind shared reference."); } - (ProjectionElem::Deref, ty::Ref(_, _, hir::Mutability::Mut), AccessDepth::Drop) => { + (ProjectionElem::Deref, ty::Ref(_, _, Mutability::Mut), AccessDepth::Drop) => { // Values behind a mutable reference are not access either by dropping a // value, or by StorageDead debug!("borrow_conflicts_with_place: drop access behind ptr"); diff --git a/compiler/rustc_mir/src/borrow_check/prefixes.rs b/compiler/rustc_mir/src/borrow_check/prefixes.rs index 6c5d42296f72b..f615b5e9561ab 100644 --- a/compiler/rustc_mir/src/borrow_check/prefixes.rs +++ b/compiler/rustc_mir/src/borrow_check/prefixes.rs @@ -9,7 +9,7 @@ use super::MirBorrowckCtxt; -use rustc_hir as hir; +use rustc_ast::Mutability; use rustc_middle::mir::{Body, Place, PlaceRef, ProjectionElem}; use rustc_middle::ty::{self, TyCtxt}; @@ -121,14 +121,14 @@ impl<'cx, 'tcx> Iterator for Prefixes<'cx, 'tcx> { let ty = Place::ty_from(cursor.local, proj_base, self.body, self.tcx).ty; match ty.kind() { - ty::RawPtr(_) | ty::Ref(_ /*rgn*/, _ /*ty*/, hir::Mutability::Not) => { + ty::RawPtr(_) | ty::Ref(_ /*rgn*/, _ /*ty*/, Mutability::Not) => { // don't continue traversing over derefs of raw pointers or shared // borrows. self.next = None; return Some(cursor); } - ty::Ref(_ /*rgn*/, _ /*ty*/, hir::Mutability::Mut) => { + ty::Ref(_ /*rgn*/, _ /*ty*/, Mutability::Mut) => { self.next = Some(PlaceRef { local: cursor.local, projection: proj_base }); return Some(cursor); diff --git a/compiler/rustc_mir/src/borrow_check/type_check/mod.rs b/compiler/rustc_mir/src/borrow_check/type_check/mod.rs index 3ace14610e2a7..96c6c77dfeefe 100644 --- a/compiler/rustc_mir/src/borrow_check/type_check/mod.rs +++ b/compiler/rustc_mir/src/borrow_check/type_check/mod.rs @@ -2164,7 +2164,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { let ty_from = match op.ty(body, tcx).kind() { ty::RawPtr(ty::TypeAndMut { ty: ty_from, - mutbl: hir::Mutability::Mut, + mutbl: Mutability::Mut, }) => ty_from, _ => { span_mirbug!( @@ -2179,7 +2179,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { let ty_to = match ty.kind() { ty::RawPtr(ty::TypeAndMut { ty: ty_to, - mutbl: hir::Mutability::Not, + mutbl: Mutability::Not, }) => ty_to, _ => { span_mirbug!( @@ -2213,7 +2213,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { let opt_ty_elem = match ty_from.kind() { ty::RawPtr(ty::TypeAndMut { - mutbl: hir::Mutability::Not, + mutbl: Mutability::Not, ty: array_ty, }) => match array_ty.kind() { ty::Array(ty_elem, _) => Some(ty_elem), @@ -2237,7 +2237,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { let ty_to = match ty.kind() { ty::RawPtr(ty::TypeAndMut { - mutbl: hir::Mutability::Not, + mutbl: Mutability::Not, ty: ty_to, }) => ty_to, _ => { @@ -2522,13 +2522,13 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> { }); match mutbl { - hir::Mutability::Not => { + Mutability::Not => { // Immutable reference. We don't need the base // to be valid for the entire lifetime of // the borrow. break; } - hir::Mutability::Mut => { + Mutability::Mut => { // Mutable reference. We *do* need the base // to be valid, because after the base becomes // invalid, someone else can use our mutable deref. diff --git a/compiler/rustc_mir/src/borrow_check/universal_regions.rs b/compiler/rustc_mir/src/borrow_check/universal_regions.rs index 4742113b1a552..7eacabe6bd805 100644 --- a/compiler/rustc_mir/src/borrow_check/universal_regions.rs +++ b/compiler/rustc_mir/src/borrow_check/universal_regions.rs @@ -13,6 +13,7 @@ //! just returns them for other code to use. use either::Either; +use rustc_ast::Movability; use rustc_data_structures::fx::FxHashMap; use rustc_errors::DiagnosticBuilder; use rustc_hir as hir; @@ -98,7 +99,7 @@ pub enum DefiningTy<'tcx> { /// The MIR is a generator. The signature is that generators take /// no parameters and return the result of /// `ClosureSubsts::generator_return_ty`. - Generator(DefId, SubstsRef<'tcx>, hir::Movability), + Generator(DefId, SubstsRef<'tcx>, Movability), /// The MIR is a fn item with the given `DefId` and substs. The signature /// of the function can be bound then with the `fn_sig` query. diff --git a/compiler/rustc_mir/src/const_eval/mod.rs b/compiler/rustc_mir/src/const_eval/mod.rs index 978d2fe000468..11de75487c1db 100644 --- a/compiler/rustc_mir/src/const_eval/mod.rs +++ b/compiler/rustc_mir/src/const_eval/mod.rs @@ -2,7 +2,7 @@ use std::convert::TryFrom; -use rustc_hir::Mutability; +use rustc_ast::Mutability; use rustc_middle::mir; use rustc_middle::ty::{self, TyCtxt}; use rustc_span::{source_map::DUMMY_SP, symbol::Symbol}; diff --git a/compiler/rustc_mir/src/interpret/intern.rs b/compiler/rustc_mir/src/interpret/intern.rs index dd5e9c9977437..3ada323d59788 100644 --- a/compiler/rustc_mir/src/interpret/intern.rs +++ b/compiler/rustc_mir/src/interpret/intern.rs @@ -51,7 +51,7 @@ enum InternMode { /// A static and its current mutability. Below shared references inside a `static mut`, /// this is *immutable*, and below mutable references inside an `UnsafeCell`, this /// is *mutable*. - Static(hir::Mutability), + Static(Mutability), /// The "base value" of a const, which can have `UnsafeCell` (as in `const FOO: Cell`), /// but that interior mutability is simply ignored. ConstBase, @@ -291,7 +291,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: CompileTimeMachine<'mir, 'tcx>> ValueVisitor<'mir #[derive(Copy, Clone, Debug, PartialEq, Hash, Eq)] pub enum InternKind { /// The `mutability` of the static, ignoring the type which may have interior mutability. - Static(hir::Mutability), + Static(Mutability), Constant, Promoted, } diff --git a/compiler/rustc_mir/src/shim.rs b/compiler/rustc_mir/src/shim.rs index 7e4d189f0b737..8acb7d583fe4c 100644 --- a/compiler/rustc_mir/src/shim.rs +++ b/compiler/rustc_mir/src/shim.rs @@ -417,7 +417,7 @@ impl CloneShimBuilder<'tcx> { let ref_loc = self.make_place( Mutability::Not, - tcx.mk_ref(tcx.lifetimes.re_erased, ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }), + tcx.mk_ref(tcx.lifetimes.re_erased, ty::TypeAndMut { ty, mutbl: Mutability::Not }), ); // `let ref_loc: &ty = &src;` @@ -722,7 +722,7 @@ fn build_call_shim<'tcx>( LocalDecl::new( tcx.mk_ref( tcx.lifetimes.re_erased, - ty::TypeAndMut { ty: sig.inputs()[0], mutbl: hir::Mutability::Mut }, + ty::TypeAndMut { ty: sig.inputs()[0], mutbl: Mutability::Mut }, ), span, ) diff --git a/compiler/rustc_mir/src/transform/check_consts/validation.rs b/compiler/rustc_mir/src/transform/check_consts/validation.rs index ab63fd03a336e..2035d71496d74 100644 --- a/compiler/rustc_mir/src/transform/check_consts/validation.rs +++ b/compiler/rustc_mir/src/transform/check_consts/validation.rs @@ -254,7 +254,7 @@ impl Validator<'mir, 'tcx> { // Ensure that the end result is `Sync` in a non-thread local `static`. let should_check_for_sync = self.const_kind() - == hir::ConstContext::Static(hir::Mutability::Not) + == hir::ConstContext::Static(Mutability::Not) && !tcx.is_thread_local_static(def_id.to_def_id()); if should_check_for_sync { @@ -342,7 +342,7 @@ impl Validator<'mir, 'tcx> { }; match *ty.kind() { - ty::Ref(_, _, hir::Mutability::Mut) => self.check_op(ops::ty::MutRef(kind)), + ty::Ref(_, _, Mutability::Mut) => self.check_op(ops::ty::MutRef(kind)), ty::Opaque(..) => self.check_op(ops::ty::ImplTrait), ty::FnPtr(..) => self.check_op(ops::ty::FnPtr(kind)), @@ -505,7 +505,7 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> { let is_allowed = match ty.kind() { // Inside a `static mut`, `&mut [...]` is allowed. ty::Array(..) | ty::Slice(_) - if self.const_kind() == hir::ConstContext::Static(hir::Mutability::Mut) => + if self.const_kind() == hir::ConstContext::Static(Mutability::Mut) => { true } diff --git a/compiler/rustc_mir/src/transform/generator.rs b/compiler/rustc_mir/src/transform/generator.rs index 1fffcf8151537..2e6b68da8c04f 100644 --- a/compiler/rustc_mir/src/transform/generator.rs +++ b/compiler/rustc_mir/src/transform/generator.rs @@ -948,7 +948,7 @@ fn create_generator_drop_shim<'tcx>( // Change the generator argument from &mut to *mut body.local_decls[SELF_ARG] = LocalDecl::with_source_info( - tcx.mk_ptr(ty::TypeAndMut { ty: gen_ty, mutbl: hir::Mutability::Mut }), + tcx.mk_ptr(ty::TypeAndMut { ty: gen_ty, mutbl: Mutability::Mut }), source_info, ); if tcx.sess.opts.debugging_opts.mir_emit_retag { @@ -1262,7 +1262,7 @@ impl<'tcx> MirPass<'tcx> for StateTransform { substs.upvar_tys().collect(), substs.witness(), substs.discr_ty(tcx), - movability == hir::Movability::Movable, + movability == Movability::Movable, ) } _ => { diff --git a/compiler/rustc_mir/src/transform/instcombine.rs b/compiler/rustc_mir/src/transform/instcombine.rs index 3ed0aea1404d4..1e2aa8eba9d53 100644 --- a/compiler/rustc_mir/src/transform/instcombine.rs +++ b/compiler/rustc_mir/src/transform/instcombine.rs @@ -1,8 +1,8 @@ //! Performs various peephole optimizations. use crate::transform::{MirPass, MirSource}; +use rustc_ast::Mutability; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use rustc_hir::Mutability; use rustc_index::vec::Idx; use rustc_middle::mir::{ visit::PlaceContext, diff --git a/compiler/rustc_mir/src/transform/nrvo.rs b/compiler/rustc_mir/src/transform/nrvo.rs index 1ffb5a87c4762..15021b30e5e3a 100644 --- a/compiler/rustc_mir/src/transform/nrvo.rs +++ b/compiler/rustc_mir/src/transform/nrvo.rs @@ -1,4 +1,4 @@ -use rustc_hir::Mutability; +use rustc_ast::Mutability; use rustc_index::bit_set::HybridBitSet; use rustc_middle::mir::visit::{MutVisitor, NonUseContext, PlaceContext, Visitor}; use rustc_middle::mir::{self, BasicBlock, Local, Location}; diff --git a/compiler/rustc_mir/src/util/elaborate_drops.rs b/compiler/rustc_mir/src/util/elaborate_drops.rs index bf0a6be9a7d8e..8daa14d78ab66 100644 --- a/compiler/rustc_mir/src/util/elaborate_drops.rs +++ b/compiler/rustc_mir/src/util/elaborate_drops.rs @@ -617,7 +617,7 @@ where let substs = tcx.mk_substs_trait(ty, &[]); let ref_ty = - tcx.mk_ref(tcx.lifetimes.re_erased, ty::TypeAndMut { ty, mutbl: hir::Mutability::Mut }); + tcx.mk_ref(tcx.lifetimes.re_erased, ty::TypeAndMut { ty, mutbl: Mutability::Mut }); let ref_place = self.new_temp(ref_ty); let unit_temp = Place::from(self.new_temp(tcx.mk_unit())); @@ -680,7 +680,7 @@ where let move_ = |place: Place<'tcx>| Operand::Move(place); let tcx = self.tcx(); - let ptr_ty = tcx.mk_ptr(ty::TypeAndMut { ty: ety, mutbl: hir::Mutability::Mut }); + let ptr_ty = tcx.mk_ptr(ty::TypeAndMut { ty: ety, mutbl: Mutability::Mut }); let ptr = Place::from(self.new_temp(ptr_ty)); let can_go = Place::from(self.new_temp(tcx.types.bool)); diff --git a/compiler/rustc_mir_build/src/build/expr/into.rs b/compiler/rustc_mir_build/src/build/expr/into.rs index 319fae5009e09..3ffe034d2b997 100644 --- a/compiler/rustc_mir_build/src/build/expr/into.rs +++ b/compiler/rustc_mir_build/src/build/expr/into.rs @@ -252,8 +252,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } ExprKind::AddressOf { mutability, arg } => { let place = match mutability { - hir::Mutability::Not => this.as_read_only_place(block, arg), - hir::Mutability::Mut => this.as_place(block, arg), + Mutability::Not => this.as_read_only_place(block, arg), + Mutability::Mut => this.as_place(block, arg), }; let address_of = Rvalue::AddressOf(mutability, unpack!(block = place)); this.cfg.push_assign(block, source_info, destination, address_of); diff --git a/compiler/rustc_mir_build/src/build/mod.rs b/compiler/rustc_mir_build/src/build/mod.rs index aa96ae8759154..cde53fc8b2d4d 100644 --- a/compiler/rustc_mir_build/src/build/mod.rs +++ b/compiler/rustc_mir_build/src/build/mod.rs @@ -864,7 +864,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { match hir_typeck_results .extract_binding_mode(tcx.sess, pat.hir_id, pat.span) { - Some(ty::BindByValue(hir::Mutability::Mut)) => { + Some(ty::BindByValue(Mutability::Mut)) => { mutability = Mutability::Mut; } Some(_) => mutability = Mutability::Not, diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs index 13e69474cfb96..525a04058a544 100644 --- a/compiler/rustc_mir_build/src/thir/cx/expr.rs +++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs @@ -3,6 +3,8 @@ use crate::thir::cx::to_ref::ToRef; use crate::thir::cx::Cx; use crate::thir::util::UserAnnotatedTyHelpers; use crate::thir::*; +use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res}; use rustc_index::vec::Idx; @@ -229,11 +231,11 @@ fn make_mirror_unadjusted<'a, 'tcx>( } } - hir::ExprKind::AddrOf(hir::BorrowKind::Ref, mutbl, ref arg) => { + hir::ExprKind::AddrOf(ast::BorrowKind::Ref, mutbl, ref arg) => { ExprKind::Borrow { borrow_kind: mutbl.to_borrow_kind(), arg: arg.to_ref() } } - hir::ExprKind::AddrOf(hir::BorrowKind::Raw, mutability, ref arg) => { + hir::ExprKind::AddrOf(ast::BorrowKind::Raw, mutability, ref arg) => { ExprKind::AddressOf { mutability, arg: arg.to_ref() } } @@ -759,11 +761,11 @@ impl ToBorrowKind for AutoBorrowMutability { } } -impl ToBorrowKind for hir::Mutability { +impl ToBorrowKind for Mutability { fn to_borrow_kind(&self) -> BorrowKind { match *self { - hir::Mutability::Mut => BorrowKind::Mut { allow_two_phase_borrow: false }, - hir::Mutability::Not => BorrowKind::Shared, + Mutability::Mut => BorrowKind::Mut { allow_two_phase_borrow: false }, + Mutability::Not => BorrowKind::Shared, } } } @@ -929,7 +931,7 @@ fn convert_var<'tcx>( ty::ClosureKind::Fn => { let ref_closure_ty = cx.tcx.mk_ref( region, - ty::TypeAndMut { ty: closure_ty, mutbl: hir::Mutability::Not }, + ty::TypeAndMut { ty: closure_ty, mutbl: Mutability::Not }, ); Expr { ty: closure_ty, @@ -949,7 +951,7 @@ fn convert_var<'tcx>( ty::ClosureKind::FnMut => { let ref_closure_ty = cx.tcx.mk_ref( region, - ty::TypeAndMut { ty: closure_ty, mutbl: hir::Mutability::Mut }, + ty::TypeAndMut { ty: closure_ty, mutbl: Mutability::Mut }, ); Expr { ty: closure_ty, diff --git a/compiler/rustc_mir_build/src/thir/mod.rs b/compiler/rustc_mir_build/src/thir/mod.rs index 4d57fd5c64f8d..36eda8244a84f 100644 --- a/compiler/rustc_mir_build/src/thir/mod.rs +++ b/compiler/rustc_mir_build/src/thir/mod.rs @@ -5,7 +5,7 @@ //! structures. use self::cx::Cx; -use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece}; +use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece, Mutability, Movability}; use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_middle::infer::canonical::Canonical; @@ -219,7 +219,7 @@ crate enum ExprKind<'tcx> { }, /// A `&raw [const|mut] $place_expr` raw borrow resulting in type `*[const|mut] T`. AddressOf { - mutability: hir::Mutability, + mutability: Mutability, arg: ExprRef<'tcx>, }, Break { @@ -268,7 +268,7 @@ crate enum ExprKind<'tcx> { closure_id: DefId, substs: UpvarSubsts<'tcx>, upvars: Vec>, - movability: Option, + movability: Option, }, Literal { literal: &'tcx Const<'tcx>, diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs index 047bf7db4c867..2860ea1f03f6e 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs @@ -285,7 +285,7 @@ fn const_not_var( fn check_for_bindings_named_same_as_variants(cx: &MatchVisitor<'_, '_>, pat: &Pat<'_>) { pat.walk_always(|p| { if let hir::PatKind::Binding(_, _, ident, None) = p.kind { - if let Some(ty::BindByValue(hir::Mutability::Not)) = + if let Some(ty::BindByValue(Mutability::Not)) = cx.typeck_results.extract_binding_mode(cx.tcx.sess, p.hir_id, p.span) { let pat_ty = cx.typeck_results.pat_ty(p).peel_refs(); diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs index 718ed78889f09..dee67c718cc22 100644 --- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs +++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs @@ -575,11 +575,11 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> { .expect("missing binding mode"); let (mutability, mode) = match bm { ty::BindByValue(mutbl) => (mutbl, BindingMode::ByValue), - ty::BindByReference(hir::Mutability::Mut) => ( + ty::BindByReference(Mutability::Mut) => ( Mutability::Not, BindingMode::ByRef(BorrowKind::Mut { allow_two_phase_borrow: false }), ), - ty::BindByReference(hir::Mutability::Not) => { + ty::BindByReference(Mutability::Not) => { (Mutability::Not, BindingMode::ByRef(BorrowKind::Shared)) } }; diff --git a/compiler/rustc_passes/src/loops.rs b/compiler/rustc_passes/src/loops.rs index 9b4da71e5e961..601d01e9094be 100644 --- a/compiler/rustc_passes/src/loops.rs +++ b/compiler/rustc_passes/src/loops.rs @@ -1,10 +1,11 @@ use Context::*; use rustc_errors::{struct_span_err, Applicability}; +use rustc_ast::Movability; use rustc_hir as hir; use rustc_hir::def_id::LocalDefId; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; -use rustc_hir::{Destination, Movability, Node}; +use rustc_hir::{Destination, Node}; use rustc_middle::hir::map::Map; use rustc_middle::ty::query::Providers; use rustc_middle::ty::TyCtxt; diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs index f6434689fec01..23fba3e006da0 100644 --- a/compiler/rustc_save_analysis/src/lib.rs +++ b/compiler/rustc_save_analysis/src/lib.rs @@ -10,6 +10,7 @@ mod span_utils; mod sig; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_ast::util::comments::beautify_doc_string; use rustc_ast_pretty::pprust::attribute_to_string; use rustc_hir as hir; @@ -858,7 +859,7 @@ impl<'tcx> SaveContext<'tcx> { struct PathCollector<'l> { tcx: TyCtxt<'l>, collected_paths: Vec<(hir::HirId, &'l hir::QPath<'l>)>, - collected_idents: Vec<(hir::HirId, Ident, hir::Mutability)>, + collected_idents: Vec<(hir::HirId, Ident, Mutability)>, } impl<'l> PathCollector<'l> { @@ -892,10 +893,10 @@ impl<'l> Visitor<'l> for PathCollector<'l> { // the data pointed at, so showing the initialising expression // is still worthwhile. hir::BindingAnnotation::Unannotated | hir::BindingAnnotation::Ref => { - hir::Mutability::Not + Mutability::Not } hir::BindingAnnotation::Mutable | hir::BindingAnnotation::RefMut => { - hir::Mutability::Mut + Mutability::Mut } }; self.collected_idents.push((p.hir_id, ident, immut)); diff --git a/compiler/rustc_save_analysis/src/sig.rs b/compiler/rustc_save_analysis/src/sig.rs index 747e198cd9324..570308c89c7cd 100644 --- a/compiler/rustc_save_analysis/src/sig.rs +++ b/compiler/rustc_save_analysis/src/sig.rs @@ -29,7 +29,7 @@ use crate::{id_from_def_id, id_from_hir_id, SaveContext}; use rls_data::{SigElement, Signature}; -use rustc_ast::Mutability; +use rustc_ast::{IsAuto, ImplPolarity, Mutability}; use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; use rustc_hir_pretty::id_to_string; @@ -158,8 +158,8 @@ impl<'hir> Sig for hir::Ty<'hir> { } hir::TyKind::Ptr(ref mt) => { let prefix = match mt.mutbl { - hir::Mutability::Mut => "*mut ", - hir::Mutability::Not => "*const ", + Mutability::Mut => "*mut ", + Mutability::Not => "*const ", }; let nested = mt.ty.make(offset + prefix.len(), id, scx)?; let text = format!("{}{}", prefix, nested.text); @@ -169,7 +169,7 @@ impl<'hir> Sig for hir::Ty<'hir> { let mut prefix = "&".to_owned(); prefix.push_str(&lifetime.name.ident().to_string()); prefix.push(' '); - if let hir::Mutability::Mut = mt.mutbl { + if let Mutability::Mut = mt.mutbl { prefix.push_str("mut "); }; @@ -332,7 +332,7 @@ impl<'hir> Sig for hir::Item<'hir> { match self.kind { hir::ItemKind::Static(ref ty, m, ref body) => { let mut text = "static ".to_owned(); - if m == hir::Mutability::Mut { + if m == Mutability::Mut { text.push_str("mut "); } let name = self.ident.to_string(); @@ -466,7 +466,7 @@ impl<'hir> Sig for hir::Item<'hir> { hir::ItemKind::Trait(is_auto, unsafety, ref generics, bounds, _) => { let mut text = String::new(); - if is_auto == hir::IsAuto::Yes { + if is_auto == IsAuto::Yes { text.push_str("auto "); } @@ -530,7 +530,7 @@ impl<'hir> Sig for hir::Item<'hir> { text.push(' '); let trait_sig = if let Some(ref t) = *of_trait { - if let hir::ImplPolarity::Negative(_) = polarity { + if let ImplPolarity::Negative(_) = polarity { text.push('!'); } let trait_sig = t.path.make(offset + text.len(), id, scx)?; diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs index 091d488138e46..7fe3b805a611d 100644 --- a/compiler/rustc_symbol_mangling/src/v0.rs +++ b/compiler/rustc_symbol_mangling/src/v0.rs @@ -1,4 +1,4 @@ -use rustc_ast::{FloatTy, IntTy, UintTy}; +use rustc_ast::{FloatTy, IntTy, UintTy, Mutability}; use rustc_data_structures::base_n; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir as hir; @@ -370,8 +370,8 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { ty::Ref(r, ty, mutbl) => { self.push(match mutbl { - hir::Mutability::Not => "R", - hir::Mutability::Mut => "Q", + Mutability::Not => "R", + Mutability::Mut => "Q", }); if *r != ty::ReErased { self = r.print(self)?; @@ -381,8 +381,8 @@ impl Printer<'tcx> for SymbolMangler<'tcx> { ty::RawPtr(mt) => { self.push(match mt.mutbl { - hir::Mutability::Not => "P", - hir::Mutability::Mut => "O", + Mutability::Not => "P", + Mutability::Mut => "O", }); self = mt.ty.print(self)?; } diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 90a8d9634ae1e..2556304db9f9a 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -7,6 +7,7 @@ use crate::autoderef::Autoderef; use crate::infer::InferCtxt; use crate::traits::normalize_projection_type; +use rustc_ast::Mutability; use rustc_data_structures::stack::ensure_sufficient_stack; use rustc_errors::{error_code, struct_span_err, Applicability, DiagnosticBuilder, Style}; use rustc_hir as hir; @@ -825,8 +826,8 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { } let suggested_ty = match mutability { - hir::Mutability::Mut => self.tcx.mk_imm_ref(region, t_type), - hir::Mutability::Not => self.tcx.mk_mut_ref(region, t_type), + Mutability::Mut => self.tcx.mk_imm_ref(region, t_type), + Mutability::Not => self.tcx.mk_mut_ref(region, t_type), }; let new_obligation = self.mk_trait_obligation_with_new_self_ty( @@ -843,7 +844,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { .sess .source_map() .span_take_while(span, |c| c.is_whitespace() || *c == '&'); - if points_at_arg && mutability == hir::Mutability::Not && refs_number > 0 { + if points_at_arg && mutability == Mutability::Not && refs_number > 0 { err.span_suggestion_verbose( sp, "consider changing this borrow's mutability", diff --git a/compiler/rustc_trait_selection/src/traits/misc.rs b/compiler/rustc_trait_selection/src/traits/misc.rs index e23f5a583b23b..01adaa3400d2d 100644 --- a/compiler/rustc_trait_selection/src/traits/misc.rs +++ b/compiler/rustc_trait_selection/src/traits/misc.rs @@ -3,6 +3,7 @@ use crate::infer::InferCtxtExt as _; use crate::traits::{self, ObligationCause}; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_infer::infer::TyCtxtInferExt; use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable}; @@ -33,7 +34,7 @@ pub fn can_type_implement_copy( | ty::Char | ty::RawPtr(..) | ty::Never - | ty::Ref(_, _, hir::Mutability::Not) => return Ok(()), + | ty::Ref(_, _, Mutability::Not) => return Ok(()), ty::Adt(adt, substs) => (adt, substs), diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs index 9cb5c232646f8..c21f0fc898f3b 100644 --- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs +++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs @@ -5,6 +5,7 @@ //! candidates. See the [rustc dev guide] for more details. //! //! [rustc dev guide]:https://rustc-dev-guide.rust-lang.org/traits/resolution.html#candidate-assembly +use rustc_ast::{Movability, Mutability}; use rustc_hir as hir; use rustc_infer::traits::{Obligation, SelectionError, TraitObligation}; use rustc_middle::ty::print::with_no_trimmed_paths; @@ -578,11 +579,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { if self.tcx().lang_items().unpin_trait() == Some(def_id) => { match movability { - hir::Movability::Static => { + Movability::Static => { // Immovable generators are never `Unpin`, so // suppress the normal auto-impl candidate for it. } - hir::Movability::Movable => { + Movability::Movable => { // Movable generators are always `Unpin`, so add an // unconditional builtin candidate. candidates.vec.push(BuiltinCandidate { has_nested: false }); diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs index 114dc79c44f50..958f59a5472c6 100644 --- a/compiler/rustc_trait_selection/src/traits/select/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs @@ -25,6 +25,7 @@ use super::{Overflow, SelectionError, Unimplemented}; use crate::infer::{InferCtxt, InferOk, TypeFreshener}; use crate::traits::error_reporting::InferCtxtExt; use crate::traits::project::ProjectionCacheKeyExt; +use rustc_ast::Mutability; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::stack::ensure_sufficient_stack; use rustc_errors::ErrorReported; @@ -1498,7 +1499,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | ty::Char | ty::RawPtr(..) | ty::Never - | ty::Ref(_, _, hir::Mutability::Not) => { + | ty::Ref(_, _, Mutability::Not) => { // Implementations provided in libcore None } @@ -1509,7 +1510,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { | ty::Generator(..) | ty::GeneratorWitness(..) | ty::Foreign(..) - | ty::Ref(_, _, hir::Mutability::Mut) => None, + | ty::Ref(_, _, Mutability::Mut) => None, ty::Array(element_ty, _) => { // (*) binder moved here diff --git a/compiler/rustc_typeck/src/check/_match.rs b/compiler/rustc_typeck/src/check/_match.rs index 7cb23dc053795..cbd11336a05ec 100644 --- a/compiler/rustc_typeck/src/check/_match.rs +++ b/compiler/rustc_typeck/src/check/_match.rs @@ -1,5 +1,6 @@ use crate::check::coercion::CoerceMany; use crate::check::{Diverges, Expectation, FnCtxt, Needs}; +use rustc_ast::Mutability; use rustc_hir::{self as hir, ExprKind}; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc_infer::traits::Obligation; @@ -488,8 +489,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .iter() .filter_map(|a| a.pat.contains_explicit_ref_binding()) .max_by_key(|m| match *m { - hir::Mutability::Mut => 1, - hir::Mutability::Not => 0, + Mutability::Mut => 1, + Mutability::Not => 0, }); if let Some(m) = contains_ref_bindings { diff --git a/compiler/rustc_typeck/src/check/callee.rs b/compiler/rustc_typeck/src/check/callee.rs index 740783aeb9d1e..59a1e4da24ec0 100644 --- a/compiler/rustc_typeck/src/check/callee.rs +++ b/compiler/rustc_typeck/src/check/callee.rs @@ -2,6 +2,7 @@ use super::method::MethodCallee; use super::{Expectation, FnCtxt, TupleArgumentsFlag}; use crate::type_error_struct; +use rustc_ast::Mutability; use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder}; use rustc_hir as hir; use rustc_hir::def::Res; @@ -231,8 +232,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { }; let mutbl = match mutbl { - hir::Mutability::Not => AutoBorrowMutability::Not, - hir::Mutability::Mut => AutoBorrowMutability::Mut { + Mutability::Not => AutoBorrowMutability::Not, + Mutability::Mut => AutoBorrowMutability::Mut { // For initial two-phase borrow // deployment, conservatively omit // overloaded function call ops. diff --git a/compiler/rustc_typeck/src/check/cast.rs b/compiler/rustc_typeck/src/check/cast.rs index 5c2bdb86f76c9..87b83aa6cd968 100644 --- a/compiler/rustc_typeck/src/check/cast.rs +++ b/compiler/rustc_typeck/src/check/cast.rs @@ -32,6 +32,7 @@ use super::FnCtxt; use crate::hir::def_id::DefId; use crate::type_error_struct; +use rustc_ast::Mutability; use rustc_ast as ast; use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported}; use rustc_hir as hir; @@ -767,7 +768,7 @@ impl<'a, 'tcx> CastCheck<'tcx> { ) -> Result { // array-ptr-cast. - if m_expr.mutbl == hir::Mutability::Not && m_cast.mutbl == hir::Mutability::Not { + if m_expr.mutbl == Mutability::Not && m_cast.mutbl == Mutability::Not { if let ty::Array(ety, _) = m_expr.ty.kind() { // Due to the limitations of LLVM global constants, // region pointers end up pointing at copies of diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs index 0647be2dfde0b..c6faf9fb01f15 100644 --- a/compiler/rustc_typeck/src/check/check.rs +++ b/compiler/rustc_typeck/src/check/check.rs @@ -2,6 +2,7 @@ use super::coercion::CoerceMany; use super::compare_method::{compare_const_impl, compare_impl_method, compare_ty_impl}; use super::*; +use rustc_ast::{Movability, Mutability}; use rustc_attr as attr; use rustc_errors::Applicability; use rustc_hir as hir; @@ -51,7 +52,7 @@ pub(super) fn check_fn<'a, 'tcx>( decl: &'tcx hir::FnDecl<'tcx>, fn_id: hir::HirId, body: &'tcx hir::Body<'tcx>, - can_be_generator: Option, + can_be_generator: Option, ) -> (FnCtxt<'a, 'tcx>, Option>) { let mut fn_sig = fn_sig; @@ -248,7 +249,7 @@ pub(super) fn check_fn<'a, 'tcx>( ty::Ref(region, ty, mutbl) => match *ty.kind() { ty::Adt(ref adt, _) => { adt.did == panic_info_did - && mutbl == hir::Mutability::Not + && mutbl == Mutability::Not && *region != RegionKind::ReStatic } _ => false, diff --git a/compiler/rustc_typeck/src/check/closure.rs b/compiler/rustc_typeck/src/check/closure.rs index 8898a5452282c..f201ef6bc7ea6 100644 --- a/compiler/rustc_typeck/src/check/closure.rs +++ b/compiler/rustc_typeck/src/check/closure.rs @@ -3,6 +3,7 @@ use super::{check_fn, Expectation, FnCtxt, GeneratorTypes}; use crate::astconv::AstConv; +use rustc_ast::{CaptureBy, Movability}; use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_hir::lang_items::LangItem; @@ -36,10 +37,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub fn check_expr_closure( &self, expr: &hir::Expr<'_>, - _capture: hir::CaptureBy, + _capture: CaptureBy, decl: &'tcx hir::FnDecl<'tcx>, body_id: hir::BodyId, - gen: Option, + gen: Option, expected: Expectation<'tcx>, ) -> Ty<'tcx> { debug!("check_expr_closure(expr={:?},expected={:?})", expr, expected); @@ -61,7 +62,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { opt_kind: Option, decl: &'tcx hir::FnDecl<'tcx>, body: &'tcx hir::Body<'tcx>, - gen: Option, + gen: Option, expected_sig: Option>, ) -> Ty<'tcx> { debug!("check_closure(opt_kind={:?}, expected_sig={:?})", opt_kind, expected_sig); diff --git a/compiler/rustc_typeck/src/check/coercion.rs b/compiler/rustc_typeck/src/check/coercion.rs index 4addee1a4c976..8b2083f531776 100644 --- a/compiler/rustc_typeck/src/check/coercion.rs +++ b/compiler/rustc_typeck/src/check/coercion.rs @@ -37,6 +37,7 @@ use crate::astconv::AstConv; use crate::check::FnCtxt; +use rustc_ast::Mutability; use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder}; use rustc_hir as hir; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; @@ -84,13 +85,13 @@ type CoerceResult<'tcx> = InferResult<'tcx, (Vec>, Ty<'tcx>)>; /// Coercing a mutable reference to an immutable works, while /// coercing `&T` to `&mut T` should be forbidden. fn coerce_mutbls<'tcx>( - from_mutbl: hir::Mutability, - to_mutbl: hir::Mutability, + from_mutbl: Mutability, + to_mutbl: Mutability, ) -> RelateResult<'tcx, ()> { match (from_mutbl, to_mutbl) { - (hir::Mutability::Mut, hir::Mutability::Mut | hir::Mutability::Not) - | (hir::Mutability::Not, hir::Mutability::Not) => Ok(()), - (hir::Mutability::Not, hir::Mutability::Mut) => Err(TypeError::Mutability), + (Mutability::Mut, Mutability::Mut | Mutability::Not) + | (Mutability::Not, Mutability::Not) => Ok(()), + (Mutability::Not, Mutability::Mut) => Err(TypeError::Mutability), } } @@ -242,7 +243,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { a: Ty<'tcx>, b: Ty<'tcx>, r_b: ty::Region<'tcx>, - mutbl_b: hir::Mutability, + mutbl_b: Mutability, ) -> CoerceResult<'tcx> { debug!("coerce_borrowed_pointer(a={:?}, b={:?})", a, b); @@ -392,7 +393,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { } }; - if ty == a && mt_a.mutbl == hir::Mutability::Not && autoderef.step_count() == 1 { + if ty == a && mt_a.mutbl == Mutability::Not && autoderef.step_count() == 1 { // As a special case, if we would produce `&'a *x`, that's // a total no-op. We end up with the type `&'a T` just as // we started with. In that case, just skip it @@ -404,7 +405,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { // `self.x` both have `&mut `type would be a move of // `self.x`, but we auto-coerce it to `foo(&mut *self.x)`, // which is a borrow. - assert_eq!(mutbl_b, hir::Mutability::Not); // can only coerce &T -> &U + assert_eq!(mutbl_b, Mutability::Not); // can only coerce &T -> &U return success(vec![], ty, obligations); } @@ -420,8 +421,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { _ => span_bug!(span, "expected a ref type, got {:?}", ty), }; let mutbl = match mutbl_b { - hir::Mutability::Not => AutoBorrowMutability::Not, - hir::Mutability::Mut => { + Mutability::Not => AutoBorrowMutability::Not, + Mutability::Mut => { AutoBorrowMutability::Mut { allow_two_phase_borrow: self.allow_two_phase } } }; @@ -497,8 +498,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { let coercion = Coercion(self.cause.span); let r_borrow = self.next_region_var(coercion); let mutbl = match mutbl_b { - hir::Mutability::Not => AutoBorrowMutability::Not, - hir::Mutability::Mut => AutoBorrowMutability::Mut { + Mutability::Not => AutoBorrowMutability::Not, + Mutability::Mut => AutoBorrowMutability::Mut { // We don't allow two-phase borrows here, at least for initial // implementation. If it happens that this coercion is a function argument, // the reborrow in coerce_borrowed_ptr will pick it up. @@ -798,7 +799,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { &self, a: Ty<'tcx>, b: Ty<'tcx>, - mutbl_b: hir::Mutability, + mutbl_b: Mutability, ) -> CoerceResult<'tcx> { debug!("coerce_unsafe_ptr(a={:?}, b={:?})", a, b); @@ -1026,7 +1027,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { { match *self.node_ty(expr.hir_id).kind() { ty::Ref(_, _, mt_orig) => { - let mutbl_adj: hir::Mutability = mutbl_adj.into(); + let mutbl_adj: Mutability = mutbl_adj.into(); // Reborrow that we can safely ignore, because // the next adjustment can only be a Deref // which will be merged into it. diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs index 7aa54e0ebcc6b..1f85c426be231 100644 --- a/compiler/rustc_typeck/src/check/compare_method.rs +++ b/compiler/rustc_typeck/src/check/compare_method.rs @@ -1,4 +1,5 @@ use crate::errors::LifetimesOrBoundsMismatchOnTrait; +use rustc_ast::Mutability; use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticId, ErrorReported}; use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; @@ -502,8 +503,8 @@ fn compare_self_type<'tcx>( let can_eq_self = |ty| infcx.can_eq(param_env, untransformed_self_ty, ty).is_ok(); match ExplicitSelf::determine(self_arg_ty, can_eq_self) { ExplicitSelf::ByValue => "self".to_owned(), - ExplicitSelf::ByReference(_, hir::Mutability::Not) => "&self".to_owned(), - ExplicitSelf::ByReference(_, hir::Mutability::Mut) => "&mut self".to_owned(), + ExplicitSelf::ByReference(_, Mutability::Not) => "&self".to_owned(), + ExplicitSelf::ByReference(_, Mutability::Mut) => "&mut self".to_owned(), _ => format!("self: {}", self_arg_ty), } }) diff --git a/compiler/rustc_typeck/src/check/demand.rs b/compiler/rustc_typeck/src/check/demand.rs index 3e66885448b9a..63705fc096cbc 100644 --- a/compiler/rustc_typeck/src/check/demand.rs +++ b/compiler/rustc_typeck/src/check/demand.rs @@ -1,4 +1,5 @@ use crate::check::FnCtxt; +use rustc_ast::{BorrowKind, Mutability}; use rustc_infer::infer::InferOk; use rustc_trait_selection::infer::InferCtxtExt as _; use rustc_trait_selection::traits::ObligationCause; @@ -451,10 +452,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // bar(&x); // error, expected &mut // ``` let ref_ty = match mutability { - hir::Mutability::Mut => { + Mutability::Mut => { self.tcx.mk_mut_ref(self.tcx.mk_region(ty::ReStatic), checked_ty) } - hir::Mutability::Not => { + Mutability::Not => { self.tcx.mk_imm_ref(self.tcx.mk_region(ty::ReStatic), checked_ty) } }; @@ -505,7 +506,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .. })) = self.tcx.hir().find(self.tcx.hir().get_parent_node(expr.hir_id)) { - if mutability == hir::Mutability::Mut { + if mutability == Mutability::Mut { // Found the following case: // fn foo(opt: &mut Option){ opt = None } // --- ^^^^ @@ -525,13 +526,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } return Some(match mutability { - hir::Mutability::Mut => ( + Mutability::Mut => ( sp, "consider mutably borrowing here", format!("{}&mut {}", field_name, sugg_expr), Applicability::MachineApplicable, ), - hir::Mutability::Not => ( + Mutability::Not => ( sp, "consider borrowing here", format!("{}&{}", field_name, sugg_expr), @@ -542,7 +543,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } ( - hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, ref expr), + hir::ExprKind::AddrOf(BorrowKind::Ref, _, ref expr), _, &ty::Ref(_, checked, _), ) if { @@ -585,10 +586,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let Ok(src) = sm.span_to_snippet(sp) { let derefs = &"*".repeat(steps); if let Some((src, applicability)) = match mutbl_b { - hir::Mutability::Mut => { + Mutability::Mut => { let new_prefix = "&mut ".to_owned() + derefs; match mutbl_a { - hir::Mutability::Mut => { + Mutability::Mut => { if let Some(s) = self.replace_prefix(&src, "&mut ", &new_prefix) { @@ -597,7 +598,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { None } } - hir::Mutability::Not => { + Mutability::Not => { if let Some(s) = self.replace_prefix(&src, "&", &new_prefix) { @@ -608,10 +609,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } } - hir::Mutability::Not => { + Mutability::Not => { let new_prefix = "&".to_owned() + derefs; match mutbl_a { - hir::Mutability::Mut => { + Mutability::Mut => { if let Some(s) = self.replace_prefix(&src, "&mut ", &new_prefix) { @@ -620,7 +621,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { None } } - hir::Mutability::Not => { + Mutability::Not => { if let Some(s) = self.replace_prefix(&src, "&", &new_prefix) { diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs index af800eab67a5e..f9e34e676f741 100644 --- a/compiler/rustc_typeck/src/check/expr.rs +++ b/compiler/rustc_typeck/src/check/expr.rs @@ -22,6 +22,7 @@ use crate::type_error_struct; use crate::errors::{AddressOfTemporaryTaken, ReturnStmtOutsideOfFnBody, StructExprNonExhaustive}; use rustc_ast as ast; +use rustc_ast::{BorrowKind, Mutability}; use rustc_ast::util::lev_distance::find_best_match_for_name; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stack::ensure_sufficient_stack; @@ -369,8 +370,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn check_expr_addr_of( &self, - kind: hir::BorrowKind, - mutbl: hir::Mutability, + kind: BorrowKind, + mutbl: Mutability, oprnd: &'tcx hir::Expr<'tcx>, expected: Expectation<'tcx>, expr: &'tcx hir::Expr<'tcx>, @@ -396,11 +397,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let tm = ty::TypeAndMut { ty, mutbl }; match kind { _ if tm.ty.references_error() => self.tcx.ty_error(), - hir::BorrowKind::Raw => { + BorrowKind::Raw => { self.check_named_place_expr(oprnd); self.tcx.mk_ptr(tm) } - hir::BorrowKind::Ref => { + BorrowKind::Ref => { // Note: at this point, we cannot say what the best lifetime // is to use for resulting pointer. We want to use the // shortest lifetime possible so as to avoid spurious borrowck diff --git a/compiler/rustc_typeck/src/check/intrinsic.rs b/compiler/rustc_typeck/src/check/intrinsic.rs index 2ee867c2dd648..568680199358e 100644 --- a/compiler/rustc_typeck/src/check/intrinsic.rs +++ b/compiler/rustc_typeck/src/check/intrinsic.rs @@ -7,6 +7,7 @@ use crate::errors::{ }; use crate::require_same_types; +use rustc_ast::Mutability; use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::def_id::DefId; @@ -175,7 +176,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { | sym::prefetch_write_instruction => ( 1, vec![ - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Not }), tcx.types.i32, ], tcx.mk_unit(), @@ -188,16 +189,16 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { sym::offset | sym::arith_offset => ( 1, vec![ - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Not }), tcx.types.isize, ], - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Not }), ), sym::copy | sym::copy_nonoverlapping => ( 1, vec![ - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Not }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Mut }), tcx.types.usize, ], tcx.mk_unit(), @@ -205,8 +206,8 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { sym::volatile_copy_memory | sym::volatile_copy_nonoverlapping_memory => ( 1, vec![ - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }), - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Mut }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Not }), tcx.types.usize, ], tcx.mk_unit(), @@ -214,7 +215,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { sym::write_bytes | sym::volatile_set_memory => ( 1, vec![ - tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }), + tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: Mutability::Mut }), tcx.types.u8, tcx.types.usize, ], @@ -349,12 +350,12 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { ) } - sym::va_start | sym::va_end => match mk_va_list_ty(hir::Mutability::Mut) { + sym::va_start | sym::va_end => match mk_va_list_ty(Mutability::Mut) { Some((va_list_ref_ty, _)) => (0, vec![va_list_ref_ty], tcx.mk_unit()), None => bug!("`va_list` language item needed for C-variadic intrinsics"), }, - sym::va_copy => match mk_va_list_ty(hir::Mutability::Not) { + sym::va_copy => match mk_va_list_ty(Mutability::Not) { Some((va_list_ref_ty, va_list_ty)) => { let va_list_ptr_ty = tcx.mk_mut_ptr(va_list_ty); (0, vec![va_list_ptr_ty, va_list_ref_ty], tcx.mk_unit()) @@ -362,7 +363,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { None => bug!("`va_list` language item needed for C-variadic intrinsics"), }, - sym::va_arg => match mk_va_list_ty(hir::Mutability::Mut) { + sym::va_arg => match mk_va_list_ty(Mutability::Mut) { Some((va_list_ref_ty, _)) => (1, vec![va_list_ref_ty], param(0)), None => bug!("`va_list` language item needed for C-variadic intrinsics"), }, diff --git a/compiler/rustc_typeck/src/check/method/confirm.rs b/compiler/rustc_typeck/src/check/method/confirm.rs index fd2700b85e279..df97eb00cbf9e 100644 --- a/compiler/rustc_typeck/src/check/method/confirm.rs +++ b/compiler/rustc_typeck/src/check/method/confirm.rs @@ -4,6 +4,7 @@ use crate::astconv::AstConv; use crate::check::{callee, FnCtxt}; use crate::hir::def_id::DefId; use crate::hir::GenericArg; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_infer::infer::{self, InferOk}; use rustc_middle::traits::{ObligationCauseCode, UnifyReceiverContext}; @@ -159,8 +160,8 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> { let region = self.next_region_var(infer::Autoref(self.span, pick.item)); target = self.tcx.mk_ref(region, ty::TypeAndMut { mutbl, ty: target }); let mutbl = match mutbl { - hir::Mutability::Not => AutoBorrowMutability::Not, - hir::Mutability::Mut => AutoBorrowMutability::Mut { + Mutability::Not => AutoBorrowMutability::Not, + Mutability::Mut => AutoBorrowMutability::Mut { // Method call receivers are the primary use case // for two-phase borrows. allow_two_phase_borrow: AllowTwoPhase::Yes, diff --git a/compiler/rustc_typeck/src/check/method/probe.rs b/compiler/rustc_typeck/src/check/method/probe.rs index c1ba29284da16..488d9e47ea490 100644 --- a/compiler/rustc_typeck/src/check/method/probe.rs +++ b/compiler/rustc_typeck/src/check/method/probe.rs @@ -9,6 +9,7 @@ use crate::hir::def::DefKind; use crate::hir::def_id::DefId; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_ast::util::lev_distance::{find_best_match_for_name, lev_distance}; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::Lrc; @@ -169,7 +170,7 @@ pub struct Pick<'tcx> { // Indicates that an autoref is applied after the optional autoderefs // // B = A | &A | &mut A - pub autoref: Option, + pub autoref: Option, // Indicates that the source expression should be "unsized" to a // target type. This should probably eventually go away in favor @@ -649,10 +650,10 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { } ty::RawPtr(ty::TypeAndMut { ty: _, mutbl }) => { let (lang_def_id1, lang_def_id2) = match mutbl { - hir::Mutability::Not => { + Mutability::Not => { (lang_items.const_ptr_impl(), lang_items.const_slice_ptr_impl()) } - hir::Mutability::Mut => { + Mutability::Mut => { (lang_items.mut_ptr_impl(), lang_items.mut_slice_ptr_impl()) } }; @@ -1091,8 +1092,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { span_bug!(self.span, "{:?} was applicable but now isn't?", step.self_ty) }); self.pick_by_value_method(step, self_ty).or_else(|| { - self.pick_autorefd_method(step, self_ty, hir::Mutability::Not) - .or_else(|| self.pick_autorefd_method(step, self_ty, hir::Mutability::Mut)) + self.pick_autorefd_method(step, self_ty, Mutability::Not) + .or_else(|| self.pick_autorefd_method(step, self_ty, Mutability::Mut)) }) }) .next() @@ -1134,7 +1135,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { &mut self, step: &CandidateStep<'tcx>, self_ty: Ty<'tcx>, - mutbl: hir::Mutability, + mutbl: Mutability, ) -> Option> { let tcx = self.tcx; diff --git a/compiler/rustc_typeck/src/check/mod.rs b/compiler/rustc_typeck/src/check/mod.rs index 97172d391ba65..5a55e3a0bb153 100644 --- a/compiler/rustc_typeck/src/check/mod.rs +++ b/compiler/rustc_typeck/src/check/mod.rs @@ -101,6 +101,7 @@ pub use inherited::{Inherited, InheritedBuilder}; use crate::astconv::AstConv; use crate::check::gather_locals::GatherLocalsVisitor; +use rustc_ast::{Movability, Mutability}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::{pluralize, struct_span_err, Applicability}; use rustc_hir as hir; @@ -162,10 +163,10 @@ pub enum Needs { } impl Needs { - fn maybe_mut_place(m: hir::Mutability) -> Self { + fn maybe_mut_place(m: Mutability) -> Self { match m { - hir::Mutability::Mut => Needs::MutPlace, - hir::Mutability::Not => Needs::None, + Mutability::Mut => Needs::MutPlace, + Mutability::Not => Needs::None, } } } @@ -640,7 +641,7 @@ struct GeneratorTypes<'tcx> { interior: Ty<'tcx>, /// Indicates if the generator is movable or static (immovable). - movability: hir::Movability, + movability: Movability, } /// Given a `DefId` for an opaque type in return position, find its parent item's return diff --git a/compiler/rustc_typeck/src/check/op.rs b/compiler/rustc_typeck/src/check/op.rs index 66975f32a1f4a..4a9da876c106c 100644 --- a/compiler/rustc_typeck/src/check/op.rs +++ b/compiler/rustc_typeck/src/check/op.rs @@ -2,6 +2,7 @@ use super::method::MethodCallee; use super::FnCtxt; +use rustc_ast::Mutability; use rustc_errors::{self, struct_span_err, Applicability, DiagnosticBuilder}; use rustc_hir as hir; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; @@ -208,8 +209,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if is_assign == IsAssign::Yes || by_ref_binop { if let ty::Ref(region, _, mutbl) = method.sig.inputs()[0].kind() { let mutbl = match mutbl { - hir::Mutability::Not => AutoBorrowMutability::Not, - hir::Mutability::Mut => AutoBorrowMutability::Mut { + Mutability::Not => AutoBorrowMutability::Not, + Mutability::Mut => AutoBorrowMutability::Mut { // Allow two-phase borrows for binops in initial deployment // since they desugar to methods allow_two_phase_borrow: AllowTwoPhase::Yes, @@ -225,8 +226,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if by_ref_binop { if let ty::Ref(region, _, mutbl) = method.sig.inputs()[1].kind() { let mutbl = match mutbl { - hir::Mutability::Not => AutoBorrowMutability::Not, - hir::Mutability::Mut => AutoBorrowMutability::Mut { + Mutability::Not => AutoBorrowMutability::Not, + Mutability::Mut => AutoBorrowMutability::Mut { // Allow two-phase borrows for binops in initial deployment // since they desugar to methods allow_two_phase_borrow: AllowTwoPhase::Yes, @@ -845,7 +846,7 @@ enum Op { /// Dereferences a single level of immutable referencing. fn deref_ty_if_possible(ty: Ty<'tcx>) -> Ty<'tcx> { match ty.kind() { - ty::Ref(_, ty, hir::Mutability::Not) => ty, + ty::Ref(_, ty, Mutability::Not) => ty, _ => ty, } } diff --git a/compiler/rustc_typeck/src/check/pat.rs b/compiler/rustc_typeck/src/check/pat.rs index 3e431a9c00090..7fc8ce28845f0 100644 --- a/compiler/rustc_typeck/src/check/pat.rs +++ b/compiler/rustc_typeck/src/check/pat.rs @@ -1,6 +1,7 @@ use crate::check::FnCtxt; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_ast::util::lev_distance::find_best_match_for_name; use rustc_data_structures::fx::FxHashMap; use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder}; @@ -112,7 +113,7 @@ impl<'tcx> FnCtxt<'_, 'tcx> { } } -const INITIAL_BM: BindingMode = BindingMode::BindByValue(hir::Mutability::Not); +const INITIAL_BM: BindingMode = BindingMode::BindByValue(Mutability::Not); /// Mode for adjusting the expected type and binding mode. enum AdjustMode { @@ -355,10 +356,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // (depending on whether we observe `&` or `&mut`). ty::BindByValue(_) | // When `ref mut`, stay a `ref mut` (on `&mut`) or downgrade to `ref` (on `&`). - ty::BindByReference(hir::Mutability::Mut) => inner_mutability, + ty::BindByReference(Mutability::Mut) => inner_mutability, // Once a `ref`, always a `ref`. // This is because a `& &mut` cannot mutate the underlying value. - ty::BindByReference(m @ hir::Mutability::Not) => m, + ty::BindByReference(m @ Mutability::Not) => m, }); } @@ -1542,7 +1543,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { &self, pat: &'tcx Pat<'tcx>, inner: &'tcx Pat<'tcx>, - mutbl: hir::Mutability, + mutbl: Mutability, expected: Ty<'tcx>, def_bm: BindingMode, ti: TopInfo<'tcx>, @@ -1586,7 +1587,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } /// Create a reference type with a fresh region variable. - fn new_ref_ty(&self, span: Span, mutbl: hir::Mutability, ty: Ty<'tcx>) -> Ty<'tcx> { + fn new_ref_ty(&self, span: Span, mutbl: Mutability, ty: Ty<'tcx>) -> Ty<'tcx> { let region = self.next_region_var(infer::PatternRegion(span)); let mt = ty::TypeAndMut { ty, mutbl }; self.tcx.mk_ref(region, mt) diff --git a/compiler/rustc_typeck/src/check/place_op.rs b/compiler/rustc_typeck/src/check/place_op.rs index 502cb562385e0..9dc2d256207f5 100644 --- a/compiler/rustc_typeck/src/check/place_op.rs +++ b/compiler/rustc_typeck/src/check/place_op.rs @@ -1,5 +1,6 @@ use crate::check::method::MethodCallee; use crate::check::{FnCtxt, PlaceOp}; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; use rustc_infer::infer::InferOk; @@ -25,7 +26,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let ok = self.try_overloaded_deref(expr.span, oprnd_ty)?; let method = self.register_infer_ok_obligations(ok); - if let ty::Ref(region, _, hir::Mutability::Not) = method.sig.inputs()[0].kind() { + if let ty::Ref(region, _, Mutability::Not) = method.sig.inputs()[0].kind() { self.apply_adjustments( oprnd_expr, vec![Adjustment { @@ -108,12 +109,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let method = self.register_infer_ok_obligations(ok); let mut adjustments = self.adjust_steps(autoderef); - if let ty::Ref(region, _, hir::Mutability::Not) = method.sig.inputs()[0].kind() { + if let ty::Ref(region, _, Mutability::Not) = method.sig.inputs()[0].kind() { adjustments.push(Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(region, AutoBorrowMutability::Not)), target: self.tcx.mk_ref( region, - ty::TypeAndMut { mutbl: hir::Mutability::Not, ty: adjusted_ty }, + ty::TypeAndMut { mutbl: Mutability::Not, ty: adjusted_ty }, ), }); } else { @@ -328,7 +329,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { debug!("convert_place_op_to_mutable: method={:?}", method); self.write_method_call(expr.hir_id, method); - let region = if let ty::Ref(r, _, hir::Mutability::Mut) = method.sig.inputs()[0].kind() { + let region = if let ty::Ref(r, _, Mutability::Mut) = method.sig.inputs()[0].kind() { r } else { span_bug!(expr.span, "input to mutable place op is not a mut ref?"); diff --git a/compiler/rustc_typeck/src/check/regionck.rs b/compiler/rustc_typeck/src/check/regionck.rs index ba0f22513a146..a8381e6d5d5d5 100644 --- a/compiler/rustc_typeck/src/check/regionck.rs +++ b/compiler/rustc_typeck/src/check/regionck.rs @@ -76,6 +76,7 @@ use crate::check::dropck; use crate::check::FnCtxt; use crate::mem_categorization as mc; use crate::middle::region; +use rustc_ast::{BorrowKind, Mutability}; use rustc_hir as hir; use rustc_hir::def_id::LocalDefId; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; @@ -407,7 +408,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RegionCtxt<'a, 'tcx> { } match expr.kind { - hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, ref base) => { + hir::ExprKind::AddrOf(BorrowKind::Ref, m, ref base) => { self.link_addr_of(expr, m, &base); intravisit::walk_expr(self, expr); @@ -520,7 +521,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> { fn link_addr_of( &mut self, expr: &hir::Expr<'_>, - mutability: hir::Mutability, + mutability: Mutability, base: &hir::Expr<'_>, ) { debug!("link_addr_of(expr={:?}, base={:?})", expr, base); @@ -615,7 +616,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> { &self, span: Span, id: hir::HirId, - mutbl: hir::Mutability, + mutbl: Mutability, cmt_borrowed: &PlaceWithHirId<'tcx>, ) { debug!( @@ -703,7 +704,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> { span: Span, borrow_region: ty::Region<'tcx>, ref_region: ty::Region<'tcx>, - ref_mutability: hir::Mutability, + ref_mutability: Mutability, ) -> bool { debug!("link_reborrowed_region: {:?} <= {:?}", borrow_region, ref_region); self.sub_regions(infer::Reborrow(span), borrow_region, ref_region); @@ -736,7 +737,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> { // know whether this scenario has occurred; but I wanted to show // how all the types get adjusted.) match ref_mutability { - hir::Mutability::Not => { + Mutability::Not => { // The reference being reborrowed is a shareable ref of // type `&'a T`. In this case, it doesn't matter where we // *found* the `&T` pointer, the memory it references will @@ -744,7 +745,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> { true } - hir::Mutability::Mut => { + Mutability::Mut => { // The reference being reborrowed is either an `&mut T`. This is // the case where recursion is needed. false diff --git a/compiler/rustc_typeck/src/check/upvar.rs b/compiler/rustc_typeck/src/check/upvar.rs index 2c3be0da5ddd0..46f7a9e70b126 100644 --- a/compiler/rustc_typeck/src/check/upvar.rs +++ b/compiler/rustc_typeck/src/check/upvar.rs @@ -33,6 +33,7 @@ use super::FnCtxt; use crate::expr_use_visitor as euv; +use rustc_ast::{CaptureBy, Mutability}; use rustc_data_structures::fx::FxIndexMap; use rustc_hir as hir; use rustc_hir::def_id::DefId; @@ -82,7 +83,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { closure_hir_id: hir::HirId, span: Span, body: &hir::Body<'_>, - capture_clause: hir::CaptureBy, + capture_clause: CaptureBy, ) { debug!("analyze_closure(id={:?}, body.id={:?})", closure_hir_id, body.id()); @@ -125,8 +126,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { closure_captures.insert(var_hir_id, upvar_id); let capture_kind = match capture_clause { - hir::CaptureBy::Value => ty::UpvarCapture::ByValue(None), - hir::CaptureBy::Ref => { + CaptureBy::Value => ty::UpvarCapture::ByValue(None), + CaptureBy::Ref => { let origin = UpvarRegion(upvar_id, span); let upvar_region = self.next_region_var(origin); let upvar_borrow = @@ -356,7 +357,7 @@ impl<'a, 'tcx> InferBorrowKind<'a, 'tcx> { // borrowed pointer implies that the // pointer itself must be unique, but not // necessarily *mutable* - ty::Ref(.., hir::Mutability::Mut) => borrow_kind = ty::UniqueImmBorrow, + ty::Ref(.., Mutability::Mut) => borrow_kind = ty::UniqueImmBorrow, _ => (), } } diff --git a/compiler/rustc_typeck/src/coherence/builtin.rs b/compiler/rustc_typeck/src/coherence/builtin.rs index 89270fb6c77a5..4351a37b1130e 100644 --- a/compiler/rustc_typeck/src/coherence/builtin.rs +++ b/compiler/rustc_typeck/src/coherence/builtin.rs @@ -2,6 +2,7 @@ //! up data structures required by type-checking/codegen. use crate::errors::{CopyImplOnNonAdt, CopyImplOnTypeWithDtor, DropImplOnWrongItem}; +use rustc_ast::Mutability; use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::def_id::{DefId, LocalDefId}; @@ -319,7 +320,7 @@ pub fn coerce_unsized_info(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUnsizedI let check_mutbl = |mt_a: ty::TypeAndMut<'tcx>, mt_b: ty::TypeAndMut<'tcx>, mk_ptr: &dyn Fn(Ty<'tcx>) -> Ty<'tcx>| { - if (mt_a.mutbl, mt_b.mutbl) == (hir::Mutability::Not, hir::Mutability::Mut) { + if (mt_a.mutbl, mt_b.mutbl) == (Mutability::Not, Mutability::Mut) { infcx .report_mismatched_types( &cause, diff --git a/compiler/rustc_typeck/src/coherence/inherent_impls.rs b/compiler/rustc_typeck/src/coherence/inherent_impls.rs index 373acb95c9e37..4fb5322aeb49e 100644 --- a/compiler/rustc_typeck/src/coherence/inherent_impls.rs +++ b/compiler/rustc_typeck/src/coherence/inherent_impls.rs @@ -8,6 +8,7 @@ //! is computed by selecting an idea from this table. use rustc_errors::struct_span_err; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; use rustc_hir::itemlikevisit::ItemLikeVisitor; @@ -122,7 +123,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { item.span, ); } - ty::RawPtr(ty::TypeAndMut { ty: inner, mutbl: hir::Mutability::Not }) + ty::RawPtr(ty::TypeAndMut { ty: inner, mutbl: Mutability::Not }) if matches!(inner.kind(), ty::Slice(_)) => { self.check_primitive_impl( @@ -134,7 +135,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { item.span, ); } - ty::RawPtr(ty::TypeAndMut { ty: inner, mutbl: hir::Mutability::Mut }) + ty::RawPtr(ty::TypeAndMut { ty: inner, mutbl: Mutability::Mut }) if matches!(inner.kind(), ty::Slice(_)) => { self.check_primitive_impl( @@ -146,7 +147,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { item.span, ); } - ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: hir::Mutability::Not }) => { + ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: Mutability::Not }) => { self.check_primitive_impl( def_id, lang_items.const_ptr_impl(), @@ -156,7 +157,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { item.span, ); } - ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: hir::Mutability::Mut }) => { + ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: Mutability::Mut }) => { self.check_primitive_impl( def_id, lang_items.mut_ptr_impl(), diff --git a/compiler/rustc_typeck/src/coherence/unsafety.rs b/compiler/rustc_typeck/src/coherence/unsafety.rs index b281092ea631d..674641034c13a 100644 --- a/compiler/rustc_typeck/src/coherence/unsafety.rs +++ b/compiler/rustc_typeck/src/coherence/unsafety.rs @@ -1,6 +1,7 @@ //! Unsafety checker: every impl either implements a trait defined in this //! crate or pertains to a type defined in this crate. +use rustc_ast::ImplPolarity; use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::itemlikevisit::ItemLikeVisitor; @@ -22,7 +23,7 @@ impl UnsafetyChecker<'tcx> { item: &'v hir::Item<'v>, impl_generics: Option<&hir::Generics<'_>>, unsafety: hir::Unsafety, - polarity: hir::ImplPolarity, + polarity: ImplPolarity, ) { let local_did = self.tcx.hir().local_def_id(item.hir_id); if let Some(trait_ref) = self.tcx.impl_trait_ref(local_did) { @@ -31,7 +32,7 @@ impl UnsafetyChecker<'tcx> { generics.params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle") }); match (trait_def.unsafety, unsafe_attr, unsafety, polarity) { - (Unsafety::Normal, None, Unsafety::Unsafe, hir::ImplPolarity::Positive) => { + (Unsafety::Normal, None, Unsafety::Unsafe, ImplPolarity::Positive) => { struct_span_err!( self.tcx.sess, item.span, @@ -42,7 +43,7 @@ impl UnsafetyChecker<'tcx> { .emit(); } - (Unsafety::Unsafe, _, Unsafety::Normal, hir::ImplPolarity::Positive) => { + (Unsafety::Unsafe, _, Unsafety::Normal, ImplPolarity::Positive) => { struct_span_err!( self.tcx.sess, item.span, @@ -57,7 +58,7 @@ impl UnsafetyChecker<'tcx> { Unsafety::Normal, Some(attr_name), Unsafety::Normal, - hir::ImplPolarity::Positive, + ImplPolarity::Positive, ) => { struct_span_err!( self.tcx.sess, @@ -69,13 +70,13 @@ impl UnsafetyChecker<'tcx> { .emit(); } - (_, _, Unsafety::Unsafe, hir::ImplPolarity::Negative(_)) => { + (_, _, Unsafety::Unsafe, ImplPolarity::Negative(_)) => { // Reported in AST validation self.tcx.sess.delay_span_bug(item.span, "unsafe negative impl"); } - (_, _, Unsafety::Normal, hir::ImplPolarity::Negative(_)) - | (Unsafety::Unsafe, _, Unsafety::Unsafe, hir::ImplPolarity::Positive) - | (Unsafety::Normal, Some(_), Unsafety::Unsafe, hir::ImplPolarity::Positive) + (_, _, Unsafety::Normal, ImplPolarity::Negative(_)) + | (Unsafety::Unsafe, _, Unsafety::Unsafe, ImplPolarity::Positive) + | (Unsafety::Normal, Some(_), Unsafety::Unsafe, ImplPolarity::Positive) | (Unsafety::Normal, None, Unsafety::Normal, _) => { // OK } diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index 9aca112a9142d..e61e18f0704a3 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -21,7 +21,7 @@ use crate::constrained_generic_params as cgp; use crate::errors; use crate::middle::resolve_lifetime as rl; use rustc_ast as ast; -use rustc_ast::MetaItemKind; +use rustc_ast::{IsAuto, ImplPolarity, MetaItemKind, Mutability}; use rustc_attr::{list_contains_name, InlineAttr, OptimizeAttr}; use rustc_data_structures::captures::Captures; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet}; @@ -1024,7 +1024,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: DefId) -> ty::TraitDef { let item = tcx.hir().expect_item(hir_id); let (is_auto, unsafety) = match item.kind { - hir::ItemKind::Trait(is_auto, unsafety, ..) => (is_auto == hir::IsAuto::Yes, unsafety), + hir::ItemKind::Trait(is_auto, unsafety, ..) => (is_auto == IsAuto::Yes, unsafety), hir::ItemKind::TraitAlias(..) => (false, hir::Unsafety::Normal), _ => span_bug!(item.span, "trait_def_of_item invoked on non-trait"), }; @@ -1616,21 +1616,21 @@ fn impl_polarity(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ImplPolarity { let is_rustc_reservation = tcx.has_attr(def_id, sym::rustc_reservation_impl); let item = tcx.hir().expect_item(hir_id); match &item.kind { - hir::ItemKind::Impl { polarity: hir::ImplPolarity::Negative(span), of_trait, .. } => { + hir::ItemKind::Impl { polarity: ImplPolarity::Negative(span), of_trait, .. } => { if is_rustc_reservation { let span = span.to(of_trait.as_ref().map(|t| t.path.span).unwrap_or(*span)); tcx.sess.span_err(span, "reservation impls can't be negative"); } ty::ImplPolarity::Negative } - hir::ItemKind::Impl { polarity: hir::ImplPolarity::Positive, of_trait: None, .. } => { + hir::ItemKind::Impl { polarity: ImplPolarity::Positive, of_trait: None, .. } => { if is_rustc_reservation { tcx.sess.span_err(item.span, "reservation impls can't be inherent"); } ty::ImplPolarity::Positive } hir::ItemKind::Impl { - polarity: hir::ImplPolarity::Positive, of_trait: Some(_), .. + polarity: ImplPolarity::Positive, of_trait: Some(_), .. } => { if is_rustc_reservation { ty::ImplPolarity::Reservation @@ -2311,7 +2311,7 @@ fn is_foreign_item(tcx: TyCtxt<'_>, def_id: DefId) -> bool { } } -fn static_mutability(tcx: TyCtxt<'_>, def_id: DefId) -> Option { +fn static_mutability(tcx: TyCtxt<'_>, def_id: DefId) -> Option { match tcx.hir().get_if_local(def_id) { Some( Node::Item(&hir::Item { kind: hir::ItemKind::Static(_, mutbl, _), .. }) diff --git a/compiler/rustc_typeck/src/variance/constraints.rs b/compiler/rustc_typeck/src/variance/constraints.rs index b2b062e40951e..a82586e51d084 100644 --- a/compiler/rustc_typeck/src/variance/constraints.rs +++ b/compiler/rustc_typeck/src/variance/constraints.rs @@ -3,8 +3,9 @@ //! The second pass over the AST determines the set of constraints. //! We walk the set of items and, for each member, generate new constraints. -use hir::def_id::{DefId, LocalDefId}; +use rustc_ast::Mutability; use rustc_hir as hir; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_middle::ty::subst::{GenericArgKind, SubstsRef}; use rustc_middle::ty::{self, Ty, TyCtxt}; @@ -469,12 +470,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { variance: VarianceTermPtr<'a>, ) { match mt.mutbl { - hir::Mutability::Mut => { + Mutability::Mut => { let invar = self.invariant(variance); self.add_constraints_from_ty(current, mt.ty, invar); } - hir::Mutability::Not => { + Mutability::Not => { self.add_constraints_from_ty(current, mt.ty, variance); } } diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 31e8c32f062ab..f8954023f909a 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -3,11 +3,11 @@ use std::iter::once; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_data_structures::fx::FxHashSet; use rustc_hir as hir; use rustc_hir::def::{CtorKind, DefKind, Res}; use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX}; -use rustc_hir::Mutability; use rustc_metadata::creader::LoadedMacro; use rustc_middle::ty; use rustc_mir::const_eval::is_min_const_fn; diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 788bb5e787b82..0fa81b8a2b861 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -10,6 +10,7 @@ pub mod types; pub mod utils; use rustc_ast as ast; +use rustc_ast::IsAuto; use rustc_attr as attr; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir as hir; @@ -1057,11 +1058,11 @@ impl Clean for doctree::TraitAlias<'_> { } } -impl Clean for hir::IsAuto { +impl Clean for IsAuto { fn clean(&self, _: &DocContext<'_>) -> bool { match *self { - hir::IsAuto::Yes => true, - hir::IsAuto::No => false, + IsAuto::Yes => true, + IsAuto::No => false, } } } diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index 223fda84871e9..4845e5a87d1ff 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -17,7 +17,7 @@ use rustc_hir as hir; use rustc_hir::def::Res; use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc_hir::lang_items::LangItem; -use rustc_hir::Mutability; +use rustc_ast::Mutability; use rustc_index::vec::IndexVec; use rustc_middle::middle::stability; use rustc_middle::ty::{AssocKind, TyCtxt}; diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index cfa51dcf4f1d1..f81bd6407e8fe 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -3,6 +3,7 @@ pub use self::StructType::*; use rustc_ast as ast; +use rustc_ast::{IsAuto, ImplPolarity, Mutability}; use rustc_span::hygiene::MacroKind; use rustc_span::{self, Span, Symbol}; @@ -155,7 +156,7 @@ pub struct OpaqueTy<'hir> { #[derive(Debug)] pub struct Static<'hir> { pub type_: &'hir hir::Ty<'hir>, - pub mutability: hir::Mutability, + pub mutability: Mutability, pub expr: hir::BodyId, pub name: Symbol, pub attrs: &'hir [ast::Attribute], @@ -175,7 +176,7 @@ pub struct Constant<'hir> { } pub struct Trait<'hir> { - pub is_auto: hir::IsAuto, + pub is_auto: IsAuto, pub unsafety: hir::Unsafety, pub name: Symbol, pub items: Vec<&'hir hir::TraitItem<'hir>>, @@ -200,7 +201,7 @@ pub struct TraitAlias<'hir> { #[derive(Debug)] pub struct Impl<'hir> { pub unsafety: hir::Unsafety, - pub polarity: hir::ImplPolarity, + pub polarity: ImplPolarity, pub defaultness: hir::Defaultness, pub constness: hir::Constness, pub generics: &'hir hir::Generics<'hir>, diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 2da9c68b1967c..5a3033e6b8d3f 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -9,6 +9,7 @@ use std::borrow::Cow; use std::cell::Cell; use std::fmt; +use rustc_ast::Mutability; use rustc_data_structures::fx::FxHashSet; use rustc_hir as hir; use rustc_span::def_id::DefId; @@ -708,8 +709,8 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> clean::Never => primitive_link(f, PrimitiveType::Never, "!"), clean::RawPointer(m, ref t) => { let m = match m { - hir::Mutability::Mut => "mut", - hir::Mutability::Not => "const", + Mutability::Mut => "mut", + Mutability::Not => "const", }; match **t { clean::Generic(_) | clean::ResolvedPath { is_generic: true, .. } => { @@ -1138,11 +1139,11 @@ impl PrintWithSpace for hir::IsAsync { } } -impl PrintWithSpace for hir::Mutability { +impl PrintWithSpace for Mutability { fn print_with_space(&self) -> &str { match self { - hir::Mutability::Not => "", - hir::Mutability::Mut => "mut ", + Mutability::Not => "", + Mutability::Mut => "mut ", } } } diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index 8b5ba7a239c5f..80a6d8795cc70 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -54,7 +54,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_feature::UnstableFeatures; use rustc_hir as hir; use rustc_hir::def_id::{DefId, LOCAL_CRATE}; -use rustc_hir::Mutability; +use rustc_ast::Mutability; use rustc_middle::middle::stability; use rustc_span::edition::Edition; use rustc_span::hygiene::MacroKind; diff --git a/src/tools/clippy/clippy_lints/src/bytecount.rs b/src/tools/clippy/clippy_lints/src/bytecount.rs index d7d02ebf985c8..2fd9cb9f48a96 100644 --- a/src/tools/clippy/clippy_lints/src/bytecount.rs +++ b/src/tools/clippy/clippy_lints/src/bytecount.rs @@ -2,9 +2,10 @@ use crate::utils::{ contains_name, get_pat_name, match_type, paths, single_segment_path, snippet_with_applicability, span_lint_and_sugg, }; use if_chain::if_chain; +use rustc_ast::BorrowKind; use rustc_ast::ast::UintTy; use rustc_errors::Applicability; -use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, UnOp}; +use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/entry.rs b/src/tools/clippy/clippy_lints/src/entry.rs index 35a5d00f4aa5a..2cb2e02156803 100644 --- a/src/tools/clippy/clippy_lints/src/entry.rs +++ b/src/tools/clippy/clippy_lints/src/entry.rs @@ -2,9 +2,10 @@ use crate::utils::SpanlessEq; use crate::utils::{get_item_name, higher, is_type_diagnostic_item, match_type, paths, snippet, snippet_opt}; use crate::utils::{snippet_with_applicability, span_lint_and_then}; use if_chain::if_chain; +use rustc_ast::BorrowKind; use rustc_errors::Applicability; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use rustc_hir::{BorrowKind, Expr, ExprKind, UnOp}; +use rustc_hir::{Expr, ExprKind, UnOp}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::hir::map::Map; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/eq_op.rs b/src/tools/clippy/clippy_lints/src/eq_op.rs index e16ec783fab79..0bf6e92341772 100644 --- a/src/tools/clippy/clippy_lints/src/eq_op.rs +++ b/src/tools/clippy/clippy_lints/src/eq_op.rs @@ -1,8 +1,9 @@ use crate::utils::{ eq_expr_value, implements_trait, in_macro, is_copy, multispan_sugg, snippet, span_lint, span_lint_and_then, }; +use rustc_ast::BorrowKind; use rustc_errors::Applicability; -use rustc_hir::{BinOp, BinOpKind, BorrowKind, Expr, ExprKind}; +use rustc_hir::{BinOp, BinOpKind, Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/explicit_write.rs b/src/tools/clippy/clippy_lints/src/explicit_write.rs index 0240e80d81418..9f6f040003ef2 100644 --- a/src/tools/clippy/clippy_lints/src/explicit_write.rs +++ b/src/tools/clippy/clippy_lints/src/explicit_write.rs @@ -1,8 +1,9 @@ use crate::utils::{is_expn_of, match_function_call, paths, span_lint, span_lint_and_sugg}; use if_chain::if_chain; +use rustc_ast::BorrowKind; use rustc_ast::ast::LitKind; use rustc_errors::Applicability; -use rustc_hir::{BorrowKind, Expr, ExprKind}; +use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/format.rs b/src/tools/clippy/clippy_lints/src/format.rs index d6541010bca23..01e6fce2d2f49 100644 --- a/src/tools/clippy/clippy_lints/src/format.rs +++ b/src/tools/clippy/clippy_lints/src/format.rs @@ -4,9 +4,10 @@ use crate::utils::{ span_lint_and_then, }; use if_chain::if_chain; +use rustc_ast::BorrowKind; use rustc_ast::ast::LitKind; use rustc_errors::Applicability; -use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, MatchSource, PatKind}; +use rustc_hir::{Arm, Expr, ExprKind, MatchSource, PatKind}; use rustc_lint::{LateContext, LateLintPass, LintContext}; use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Span; diff --git a/src/tools/clippy/clippy_lints/src/functions.rs b/src/tools/clippy/clippy_lints/src/functions.rs index 50b39cf4ea7c0..30bfa03787176 100644 --- a/src/tools/clippy/clippy_lints/src/functions.rs +++ b/src/tools/clippy/clippy_lints/src/functions.rs @@ -4,6 +4,7 @@ use crate::utils::{ trait_ref_of_method, type_is_unsafe_function, }; use rustc_ast::ast::Attribute; +use rustc_ast::Mutability; use rustc_data_structures::fx::FxHashSet; use rustc_errors::Applicability; use rustc_hir as hir; @@ -521,7 +522,7 @@ fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, tys: &m ty::Tuple(ref substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)), ty::Array(ty, _) | ty::Slice(ty) => is_mutable_ty(cx, ty, span, tys), ty::RawPtr(ty::TypeAndMut { ty, mutbl }) | ty::Ref(_, ty, mutbl) => { - mutbl == hir::Mutability::Mut || is_mutable_ty(cx, ty, span, tys) + mutbl == Mutability::Mut || is_mutable_ty(cx, ty, span, tys) }, // calling something constitutes a side effect, so return true on all callables // also never calls need not be used, so return true for them, too @@ -630,7 +631,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> { tys.clear(); } }, - Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mut, ref target) => { + Assign(ref target, ..) | AssignOp(_, ref target, _) | AddrOf(_, Mutability::Mut, ref target) => { self.mutates_static |= is_mutated_static(self.cx, target) }, _ => {}, diff --git a/src/tools/clippy/clippy_lints/src/infinite_iter.rs b/src/tools/clippy/clippy_lints/src/infinite_iter.rs index 129abd7d89749..184b2eadfad4b 100644 --- a/src/tools/clippy/clippy_lints/src/infinite_iter.rs +++ b/src/tools/clippy/clippy_lints/src/infinite_iter.rs @@ -1,4 +1,5 @@ -use rustc_hir::{BorrowKind, Expr, ExprKind}; +use rustc_ast::BorrowKind; +use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/loops.rs b/src/tools/clippy/clippy_lints/src/loops.rs index 3410341a1e3c5..456289f486e9d 100644 --- a/src/tools/clippy/clippy_lints/src/loops.rs +++ b/src/tools/clippy/clippy_lints/src/loops.rs @@ -11,13 +11,14 @@ use crate::utils::{ }; use if_chain::if_chain; use rustc_ast::ast; +use rustc_ast::{BorrowKind, Mutability}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::Applicability; use rustc_hir::def::{DefKind, Res}; use rustc_hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor}; use rustc_hir::{ - def_id, BinOpKind, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand, - Local, LoopSource, MatchSource, Mutability, Node, Pat, PatKind, QPath, Stmt, StmtKind, + def_id, BinOpKind, BindingAnnotation, Block, Expr, ExprKind, GenericArg, HirId, InlineAsmOperand, + Local, LoopSource, MatchSource, Node, Pat, PatKind, QPath, Stmt, StmtKind, }; use rustc_infer::infer::TyCtxtInferExt; use rustc_lint::{LateContext, LateLintPass, LintContext}; diff --git a/src/tools/clippy/clippy_lints/src/manual_strip.rs b/src/tools/clippy/clippy_lints/src/manual_strip.rs index 4afb0ab3badb0..b99a305d17cdb 100644 --- a/src/tools/clippy/clippy_lints/src/manual_strip.rs +++ b/src/tools/clippy/clippy_lints/src/manual_strip.rs @@ -5,11 +5,12 @@ use crate::utils::{ }; use if_chain::if_chain; +use rustc_ast::BorrowKind; use rustc_ast::ast::LitKind; use rustc_hir::def::Res; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use rustc_hir::BinOpKind; -use rustc_hir::{BorrowKind, Expr, ExprKind}; +use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::hir::map::Map; use rustc_middle::ty; diff --git a/src/tools/clippy/clippy_lints/src/map_clone.rs b/src/tools/clippy/clippy_lints/src/map_clone.rs index 6d1c2ffbfbdd2..2df4414ed1334 100644 --- a/src/tools/clippy/clippy_lints/src/map_clone.rs +++ b/src/tools/clippy/clippy_lints/src/map_clone.rs @@ -59,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for MapClone { let closure_expr = remove_blocks(&closure_body.value); then { match closure_body.params[0].pat.kind { - hir::PatKind::Ref(ref inner, hir::Mutability::Not) => if let hir::PatKind::Binding( + hir::PatKind::Ref(ref inner, Mutability::Not) => if let hir::PatKind::Binding( hir::BindingAnnotation::Unannotated, .., name, None ) = inner.kind { if ident_eq(name, closure_expr) { diff --git a/src/tools/clippy/clippy_lints/src/map_err_ignore.rs b/src/tools/clippy/clippy_lints/src/map_err_ignore.rs index 5298e16a04d9b..2741daa988cd9 100644 --- a/src/tools/clippy/clippy_lints/src/map_err_ignore.rs +++ b/src/tools/clippy/clippy_lints/src/map_err_ignore.rs @@ -1,6 +1,7 @@ use crate::utils::span_lint_and_help; -use rustc_hir::{CaptureBy, Expr, ExprKind, PatKind}; +use rustc_ast::CaptureBy; +use rustc_hir::{Expr, ExprKind, PatKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/matches.rs b/src/tools/clippy/clippy_lints/src/matches.rs index b1a4e06d4c32f..e5885665dceb5 100644 --- a/src/tools/clippy/clippy_lints/src/matches.rs +++ b/src/tools/clippy/clippy_lints/src/matches.rs @@ -9,11 +9,12 @@ use crate::utils::{ span_lint_and_then, }; use if_chain::if_chain; +use rustc_ast::{BorrowKind, Mutability}; use rustc_ast::ast::LitKind; use rustc_errors::Applicability; use rustc_hir::def::CtorKind; use rustc_hir::{ - Arm, BindingAnnotation, Block, BorrowKind, Expr, ExprKind, Guard, Local, MatchSource, Mutability, Node, Pat, + Arm, BindingAnnotation, Block, Expr, ExprKind, Guard, Local, MatchSource, Node, Pat, PatKind, QPath, RangeEnd, }; use rustc_lint::{LateContext, LateLintPass, LintContext}; diff --git a/src/tools/clippy/clippy_lints/src/mem_discriminant.rs b/src/tools/clippy/clippy_lints/src/mem_discriminant.rs index c71c2ee7d70af..90463f7560f92 100644 --- a/src/tools/clippy/clippy_lints/src/mem_discriminant.rs +++ b/src/tools/clippy/clippy_lints/src/mem_discriminant.rs @@ -1,7 +1,8 @@ use crate::utils::{match_def_path, paths, snippet, span_lint_and_then, walk_ptrs_ty_depth}; use if_chain::if_chain; use rustc_errors::Applicability; -use rustc_hir::{BorrowKind, Expr, ExprKind}; +use rustc_ast::BorrowKind; +use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/mem_replace.rs b/src/tools/clippy/clippy_lints/src/mem_replace.rs index bb0acecc5a92d..b20758abd8e5d 100644 --- a/src/tools/clippy/clippy_lints/src/mem_replace.rs +++ b/src/tools/clippy/clippy_lints/src/mem_replace.rs @@ -3,8 +3,9 @@ use crate::utils::{ span_lint_and_sugg, span_lint_and_then, }; use if_chain::if_chain; +use rustc_ast::{BorrowKind, Mutability}; use rustc_errors::Applicability; -use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, QPath}; +use rustc_hir::{Expr, ExprKind, QPath}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::lint::in_external_macro; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs index dadd0f8ebb7c8..c56e90bb9cee4 100644 --- a/src/tools/clippy/clippy_lints/src/methods/mod.rs +++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs @@ -12,6 +12,7 @@ use std::iter; use bind_instead_of_map::BindInsteadOfMap; use if_chain::if_chain; use rustc_ast::ast; +use rustc_ast::Mutability; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::intravisit::{self, Visitor}; @@ -1875,7 +1876,7 @@ fn lint_expect_fun_call( let mut arg_root = arg; loop { arg_root = match &arg_root.kind { - hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => expr, + hir::ExprKind::AddrOf(ast::BorrowKind::Ref, _, expr) => expr, hir::ExprKind::MethodCall(method_name, _, call_args, _) => { if call_args.len() == 1 && (method_name.ident.name == sym!(as_str) || method_name.ident.name == sym!(as_ref)) @@ -1953,7 +1954,7 @@ fn lint_expect_fun_call( applicability: &mut Applicability, ) -> Vec { if_chain! { - if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, ref format_arg) = a.kind; + if let hir::ExprKind::AddrOf(ast::BorrowKind::Ref, _, ref format_arg) = a.kind; if let hir::ExprKind::Match(ref format_arg_expr, _, _) = format_arg.kind; if let hir::ExprKind::Tup(ref format_arg_expr_tup) = format_arg_expr.kind; @@ -1970,7 +1971,7 @@ fn lint_expect_fun_call( fn is_call(node: &hir::ExprKind<'_>) -> bool { match node { - hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => { + hir::ExprKind::AddrOf(ast::BorrowKind::Ref, _, expr) => { is_call(&expr.kind) }, hir::ExprKind::Call(..) @@ -3329,8 +3330,8 @@ fn ty_has_iter_method(cx: &LateContext<'_>, self_ref_ty: Ty<'_>) -> Option<(&'st _ => unreachable!(), }; let method_name = match mutbl { - hir::Mutability::Not => "iter", - hir::Mutability::Mut => "iter_mut", + Mutability::Not => "iter", + Mutability::Mut => "iter_mut", }; (ty_name, method_name) }) @@ -3403,7 +3404,7 @@ fn lint_option_as_ref_deref<'tcx>( map_args: &[hir::Expr<'_>], is_mut: bool, ) { - let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not); + let same_mutability = |m| (is_mut && m == &Mutability::Mut) || (!is_mut && m == &Mutability::Not); let option_ty = cx.typeck_results().expr_ty(&as_ref_args[0]); if !is_type_diagnostic_item(cx, option_ty, sym!(option_type)) { @@ -3455,7 +3456,7 @@ fn lint_option_as_ref_deref<'tcx>( } } }, - hir::ExprKind::AddrOf(hir::BorrowKind::Ref, m, ref inner) if same_mutability(m) => { + hir::ExprKind::AddrOf(ast::BorrowKind::Ref, m, ref inner) if same_mutability(m) => { if_chain! { if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner1) = inner.kind; if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner2) = inner1.kind; @@ -3667,14 +3668,14 @@ impl SelfKind { } } - fn matches_ref<'a>(cx: &LateContext<'a>, mutability: hir::Mutability, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool { + fn matches_ref<'a>(cx: &LateContext<'a>, mutability: Mutability, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool { if let ty::Ref(_, t, m) = *ty.kind() { return m == mutability && t == parent_ty; } let trait_path = match mutability { - hir::Mutability::Not => &paths::ASREF_TRAIT, - hir::Mutability::Mut => &paths::ASMUT_TRAIT, + Mutability::Not => &paths::ASREF_TRAIT, + Mutability::Mut => &paths::ASMUT_TRAIT, }; let trait_def_id = match get_trait_def_id(cx, trait_path) { @@ -3686,8 +3687,8 @@ impl SelfKind { match self { Self::Value => matches_value(cx, parent_ty, ty), - Self::Ref => matches_ref(cx, hir::Mutability::Not, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty), - Self::RefMut => matches_ref(cx, hir::Mutability::Mut, parent_ty, ty), + Self::Ref => matches_ref(cx, Mutability::Not, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty), + Self::RefMut => matches_ref(cx, Mutability::Mut, parent_ty, ty), Self::No => ty != parent_ty, } } diff --git a/src/tools/clippy/clippy_lints/src/misc.rs b/src/tools/clippy/clippy_lints/src/misc.rs index 909e79f661a6d..4bf4097be685f 100644 --- a/src/tools/clippy/clippy_lints/src/misc.rs +++ b/src/tools/clippy/clippy_lints/src/misc.rs @@ -1,9 +1,10 @@ use if_chain::if_chain; +use rustc_ast::Mutability; use rustc_ast::ast::LitKind; use rustc_errors::Applicability; use rustc_hir::intravisit::FnKind; use rustc_hir::{ - self as hir, def, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, HirId, Mutability, PatKind, Stmt, + self as hir, def, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, HirId, PatKind, Stmt, StmtKind, TyKind, UnOp, }; use rustc_lint::{LateContext, LateLintPass}; diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs index 8a2dbdc50eaea..593eb1ebfe694 100644 --- a/src/tools/clippy/clippy_lints/src/mut_key.rs +++ b/src/tools/clippy/clippy_lints/src/mut_key.rs @@ -1,4 +1,5 @@ use crate::utils::{match_def_path, paths, span_lint, trait_ref_of_method}; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty::{Adt, Array, RawPtr, Ref, Slice, Tuple, Ty, TypeAndMut}; @@ -113,7 +114,7 @@ fn check_ty<'tcx>(cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) { fn is_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) -> bool { match *ty.kind() { RawPtr(TypeAndMut { ty: inner_ty, mutbl }) | Ref(_, inner_ty, mutbl) => { - mutbl == hir::Mutability::Mut || is_mutable_type(cx, inner_ty, span) + mutbl == Mutability::Mut || is_mutable_type(cx, inner_ty, span) }, Slice(inner_ty) => is_mutable_type(cx, inner_ty, span), Array(inner_ty, size) => { diff --git a/src/tools/clippy/clippy_lints/src/mut_mut.rs b/src/tools/clippy/clippy_lints/src/mut_mut.rs index 2f3cdb894f01c..01db6555b6c45 100644 --- a/src/tools/clippy/clippy_lints/src/mut_mut.rs +++ b/src/tools/clippy/clippy_lints/src/mut_mut.rs @@ -1,4 +1,6 @@ use crate::utils::{higher, span_lint}; +use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_hir as hir; use rustc_hir::intravisit; use rustc_lint::{LateContext, LateLintPass, LintContext}; @@ -61,15 +63,15 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { // Let's ignore the generated code. intravisit::walk_expr(self, arg); intravisit::walk_expr(self, body); - } else if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, ref e) = expr.kind { - if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) = e.kind { + } else if let hir::ExprKind::AddrOf(ast::BorrowKind::Ref, Mutability::Mut, ref e) = expr.kind { + if let hir::ExprKind::AddrOf(ast::BorrowKind::Ref, Mutability::Mut, _) = e.kind { span_lint( self.cx, MUT_MUT, expr.span, "generally you want to avoid `&mut &mut _` if possible", ); - } else if let ty::Ref(_, _, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() { + } else if let ty::Ref(_, _, Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() { span_lint( self.cx, MUT_MUT, @@ -85,14 +87,14 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { _, hir::MutTy { ty: ref pty, - mutbl: hir::Mutability::Mut, + mutbl: Mutability::Mut, }, ) = ty.kind { if let hir::TyKind::Rptr( _, hir::MutTy { - mutbl: hir::Mutability::Mut, + mutbl: Mutability::Mut, .. }, ) = pty.kind diff --git a/src/tools/clippy/clippy_lints/src/mut_reference.rs b/src/tools/clippy/clippy_lints/src/mut_reference.rs index 3f0b765df1561..70674dc36ebba 100644 --- a/src/tools/clippy/clippy_lints/src/mut_reference.rs +++ b/src/tools/clippy/clippy_lints/src/mut_reference.rs @@ -1,5 +1,6 @@ use crate::utils::span_lint; -use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability}; +use rustc_ast::{BorrowKind, Mutability}; +use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty::subst::Subst; use rustc_middle::ty::{self, Ty}; diff --git a/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs b/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs index cc635c2a202f6..f9537ae1a7d4f 100644 --- a/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs +++ b/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs @@ -1,7 +1,8 @@ use crate::utils::{is_direct_expn_of, span_lint}; use if_chain::if_chain; +use rustc_ast::{BorrowKind, Mutability}; use rustc_hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; -use rustc_hir::{BorrowKind, Expr, ExprKind, MatchSource, Mutability, StmtKind, UnOp}; +use rustc_hir::{Expr, ExprKind, MatchSource, StmtKind, UnOp}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::hir::map::Map; use rustc_middle::ty; diff --git a/src/tools/clippy/clippy_lints/src/needless_borrow.rs b/src/tools/clippy/clippy_lints/src/needless_borrow.rs index b71d5496a37a3..525f8e4bd59ce 100644 --- a/src/tools/clippy/clippy_lints/src/needless_borrow.rs +++ b/src/tools/clippy/clippy_lints/src/needless_borrow.rs @@ -4,8 +4,9 @@ use crate::utils::{snippet_opt, span_lint_and_then}; use if_chain::if_chain; +use rustc_ast::{BorrowKind, Mutability}; use rustc_errors::Applicability; -use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, HirId, Item, Mutability, Pat, PatKind}; +use rustc_hir::{BindingAnnotation, Expr, ExprKind, HirId, Item, Pat, PatKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_middle::ty::adjustment::{Adjust, Adjustment}; diff --git a/src/tools/clippy/clippy_lints/src/needless_borrowed_ref.rs b/src/tools/clippy/clippy_lints/src/needless_borrowed_ref.rs index 85184fdea4779..fe61bb274b05d 100644 --- a/src/tools/clippy/clippy_lints/src/needless_borrowed_ref.rs +++ b/src/tools/clippy/clippy_lints/src/needless_borrowed_ref.rs @@ -4,8 +4,9 @@ use crate::utils::{snippet_with_applicability, span_lint_and_then}; use if_chain::if_chain; +use rustc_ast::Mutability; use rustc_errors::Applicability; -use rustc_hir::{BindingAnnotation, Mutability, Node, Pat, PatKind}; +use rustc_hir::{BindingAnnotation, Node, Pat, PatKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/option_if_let_else.rs b/src/tools/clippy/clippy_lints/src/option_if_let_else.rs index 4a3eb9c983a11..49cb067dfc6f8 100644 --- a/src/tools/clippy/clippy_lints/src/option_if_let_else.rs +++ b/src/tools/clippy/clippy_lints/src/option_if_let_else.rs @@ -4,9 +4,10 @@ use crate::utils::sugg::Sugg; use crate::utils::{is_type_diagnostic_item, paths, span_lint_and_sugg}; use if_chain::if_chain; +use rustc_ast::Mutability; use rustc_errors::Applicability; use rustc_hir::intravisit::{NestedVisitorMap, Visitor}; -use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, Mutability, PatKind, UnOp}; +use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, MatchSource, PatKind, UnOp}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::hir::map::Map; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs index 5539331d0460b..c42f9ddca48e3 100644 --- a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs +++ b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs @@ -1,6 +1,7 @@ use crate::utils::{last_path_segment, span_lint_and_help}; +use rustc_ast::Mutability; use rustc_hir::{ - intravisit, Body, Expr, ExprKind, FieldPat, FnDecl, HirId, LocalSource, MatchSource, Mutability, Pat, PatKind, + intravisit, Body, Expr, ExprKind, FieldPat, FnDecl, HirId, LocalSource, MatchSource, Pat, PatKind, QPath, Stmt, StmtKind, }; use rustc_lint::{LateContext, LateLintPass, LintContext}; diff --git a/src/tools/clippy/clippy_lints/src/ptr.rs b/src/tools/clippy/clippy_lints/src/ptr.rs index 6b1c848a9467b..6c1c274ccddcf 100644 --- a/src/tools/clippy/clippy_lints/src/ptr.rs +++ b/src/tools/clippy/clippy_lints/src/ptr.rs @@ -6,10 +6,11 @@ use crate::utils::{ span_lint_and_then, walk_ptrs_hir_ty, }; use if_chain::if_chain; +use rustc_ast::Mutability; use rustc_errors::Applicability; use rustc_hir::{ BinOpKind, BodyId, Expr, ExprKind, FnDecl, FnRetTy, GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, - Lifetime, MutTy, Mutability, Node, PathSegment, QPath, TraitFn, TraitItem, TraitItemKind, Ty, TyKind, + Lifetime, MutTy, Node, PathSegment, QPath, TraitFn, TraitItem, TraitItemKind, Ty, TyKind, }; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; diff --git a/src/tools/clippy/clippy_lints/src/regex.rs b/src/tools/clippy/clippy_lints/src/regex.rs index dfc158661cbf6..62dee8d973dd0 100644 --- a/src/tools/clippy/clippy_lints/src/regex.rs +++ b/src/tools/clippy/clippy_lints/src/regex.rs @@ -1,9 +1,10 @@ use crate::consts::{constant, Constant}; use crate::utils::{match_def_path, paths, span_lint, span_lint_and_help}; use if_chain::if_chain; +use rustc_ast::BorrowKind; use rustc_ast::ast::{LitKind, StrStyle}; use rustc_data_structures::fx::FxHashSet; -use rustc_hir::{BorrowKind, Expr, ExprKind, HirId}; +use rustc_hir::{Expr, ExprKind, HirId}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::source_map::{BytePos, Span}; diff --git a/src/tools/clippy/clippy_lints/src/transmute.rs b/src/tools/clippy/clippy_lints/src/transmute.rs index c75adb62f2575..d1fd5b53431f6 100644 --- a/src/tools/clippy/clippy_lints/src/transmute.rs +++ b/src/tools/clippy/clippy_lints/src/transmute.rs @@ -4,8 +4,9 @@ use crate::utils::{ }; use if_chain::if_chain; use rustc_ast as ast; +use rustc_ast::Mutability; use rustc_errors::Applicability; -use rustc_hir::{Expr, ExprKind, GenericArg, Mutability, QPath, TyKind, UnOp}; +use rustc_hir::{Expr, ExprKind, GenericArg, QPath, TyKind, UnOp}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty::{self, cast::CastKind, Ty}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/trivially_copy_pass_by_ref.rs b/src/tools/clippy/clippy_lints/src/trivially_copy_pass_by_ref.rs index 1f06d2dbe9144..8afcbdbaf6d5c 100644 --- a/src/tools/clippy/clippy_lints/src/trivially_copy_pass_by_ref.rs +++ b/src/tools/clippy/clippy_lints/src/trivially_copy_pass_by_ref.rs @@ -3,10 +3,11 @@ use std::cmp; use crate::utils::{is_copy, is_self_ty, snippet, span_lint_and_sugg}; use if_chain::if_chain; use rustc_ast::attr; +use rustc_ast::Mutability; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_hir::intravisit::FnKind; -use rustc_hir::{Body, FnDecl, HirId, ItemKind, MutTy, Mutability, Node}; +use rustc_hir::{Body, FnDecl, HirId, ItemKind, MutTy, Node}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_session::config::Config as SessionConfig; diff --git a/src/tools/clippy/clippy_lints/src/types.rs b/src/tools/clippy/clippy_lints/src/types.rs index a29a199b8c3aa..24af8cbe89cb8 100644 --- a/src/tools/clippy/clippy_lints/src/types.rs +++ b/src/tools/clippy/clippy_lints/src/types.rs @@ -5,13 +5,13 @@ use std::cmp::Ordering; use std::collections::BTreeMap; use if_chain::if_chain; -use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy}; +use rustc_ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy, Mutability}; use rustc_errors::{Applicability, DiagnosticBuilder}; use rustc_hir as hir; use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor}; use rustc_hir::{ BinOpKind, Block, Body, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, GenericParamKind, HirId, ImplItem, - ImplItemKind, Item, ItemKind, Lifetime, Local, MatchSource, MutTy, Mutability, Node, QPath, Stmt, StmtKind, + ImplItemKind, Item, ItemKind, Lifetime, Local, MatchSource, MutTy, Node, QPath, Stmt, StmtKind, TraitFn, TraitItem, TraitItemKind, TyKind, UnOp, }; use rustc_lint::{LateContext, LateLintPass, LintContext}; diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_sort_by.rs b/src/tools/clippy/clippy_lints/src/unnecessary_sort_by.rs index 9b6a9075a2954..290896a349fd7 100644 --- a/src/tools/clippy/clippy_lints/src/unnecessary_sort_by.rs +++ b/src/tools/clippy/clippy_lints/src/unnecessary_sort_by.rs @@ -1,8 +1,9 @@ use crate::utils; use crate::utils::sugg::Sugg; use if_chain::if_chain; +use rustc_ast::Mutability; use rustc_errors::Applicability; -use rustc_hir::{Expr, ExprKind, Mutability, Param, Pat, PatKind, Path, PathSegment, QPath}; +use rustc_hir::{Expr, ExprKind, Param, Pat, PatKind, Path, PathSegment, QPath}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty::{self, subst::GenericArgKind}; use rustc_session::{declare_lint_pass, declare_tool_lint}; diff --git a/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs b/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs index c7263f48965a5..2734813773381 100644 --- a/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs +++ b/src/tools/clippy/clippy_lints/src/utils/hir_utils.rs @@ -1,9 +1,10 @@ use crate::consts::{constant_context, constant_simple}; use crate::utils::differing_macro_contexts; +use rustc_ast::{BorrowKind, CaptureBy}; use rustc_ast::ast::InlineAsmTemplatePiece; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_hir::{ - BinOpKind, Block, BlockCheckMode, BodyId, BorrowKind, CaptureBy, Expr, ExprKind, Field, FieldPat, FnRetTy, + BinOpKind, Block, BlockCheckMode, BodyId, Expr, ExprKind, Field, FieldPat, FnRetTy, GenericArg, GenericArgs, Guard, InlineAsmOperand, Lifetime, LifetimeName, ParamName, Pat, PatKind, Path, PathSegment, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding, }; diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints.rs index bfe426a25eb89..3889b7c17052c 100644 --- a/src/tools/clippy/clippy_lints/src/utils/internal_lints.rs +++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints.rs @@ -3,7 +3,7 @@ use crate::utils::{ snippet, span_lint, span_lint_and_help, span_lint_and_sugg, SpanlessEq, }; use if_chain::if_chain; -use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, NodeId}; +use rustc_ast::ast::{Crate as AstCrate, ItemKind, LitKind, Mutability, NodeId}; use rustc_ast::visit::FnKind; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_errors::Applicability; @@ -11,7 +11,7 @@ use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; use rustc_hir::hir_id::CRATE_HIR_ID; use rustc_hir::intravisit::{NestedVisitorMap, Visitor}; -use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Mutability, Node, Path, StmtKind, Ty, TyKind}; +use rustc_hir::{Crate, Expr, ExprKind, HirId, Item, MutTy, Node, Path, StmtKind, Ty, TyKind}; use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass}; use rustc_middle::hir::map::Map; use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass}; diff --git a/src/tools/clippy/clippy_lints/src/utils/qualify_min_const_fn.rs b/src/tools/clippy/clippy_lints/src/utils/qualify_min_const_fn.rs index 6809b1fa88d35..a9b7a1f8f5c97 100644 --- a/src/tools/clippy/clippy_lints/src/utils/qualify_min_const_fn.rs +++ b/src/tools/clippy/clippy_lints/src/utils/qualify_min_const_fn.rs @@ -91,7 +91,7 @@ fn check_ty(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult { }; match ty.kind() { - ty::Ref(_, _, hir::Mutability::Mut) => { + ty::Ref(_, _, Mutability::Mut) => { return Err((span, "mutable references in const fn are unstable".into())); } ty::Opaque(..) => return Err((span, "`impl Trait` in const fn is unstable".into())), diff --git a/src/tools/clippy/clippy_lints/src/vec.rs b/src/tools/clippy/clippy_lints/src/vec.rs index 149cceb39dd99..74c6de6f58ad9 100644 --- a/src/tools/clippy/clippy_lints/src/vec.rs +++ b/src/tools/clippy/clippy_lints/src/vec.rs @@ -2,8 +2,9 @@ use crate::consts::{constant, Constant}; use crate::rustc_target::abi::LayoutOf; use crate::utils::{higher, is_copy, snippet_with_applicability, span_lint_and_sugg}; use if_chain::if_chain; +use rustc_ast::BorrowKind; use rustc_errors::Applicability; -use rustc_hir::{BorrowKind, Expr, ExprKind}; +use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty::{self, Ty}; use rustc_session::{declare_tool_lint, impl_lint_pass};