Rollup of 5 pull requests

src/libcore/ptr/const_ptr.rs

@@ -3,8 +3,6 @@ use crate::cmp::Ordering::{self, Equal, Greater, Less};
 use crate::intrinsics;
 use crate::mem;
 
-// ignore-tidy-undocumented-unsafe
-
 #[lang = "const_ptr"]
 impl<T: ?Sized> *const T {
  /// Returns `true` if the pointer is null.
@@ -215,6 +213,7 @@ impl<T: ?Sized> *const T {
  where
  T: Sized,
  {
+ // SAFETY: the `arith_offset` intrinsic has no prerequisites to be called.
  unsafe { intrinsics::arith_offset(self, count) }
  }
 
@@ -702,6 +701,7 @@ impl<T: ?Sized> *const T {
  if !align.is_power_of_two() {
  panic!("align_offset: align is not a power-of-two");
  }
+ // SAFETY: `align` has been checked to be a power of 2 above
  unsafe { align_offset(self, align) }
  }
 }
@@ -729,6 +729,8 @@ impl<T> *const [T] {
  #[unstable(feature = "slice_ptr_len", issue = "71146")]
  #[rustc_const_unstable(feature = "const_slice_ptr_len", issue = "71146")]
  pub const fn len(self) -> usize {
+ // SAFETY: this is safe because `*const [T]` and `FatPtr<T>` have the same layout.
+ // Only `std` can make this guarantee.
  unsafe { Repr { rust: self }.raw }.len
  }
 }

src/libcore/ptr/mut_ptr.rs

@@ -2,8 +2,6 @@ use super::*;
 use crate::cmp::Ordering::{self, Equal, Greater, Less};
 use crate::intrinsics;
 
-// ignore-tidy-undocumented-unsafe
-
 #[lang = "mut_ptr"]
 impl<T: ?Sized> *mut T {
  /// Returns `true` if the pointer is null.
@@ -208,6 +206,7 @@ impl<T: ?Sized> *mut T {
  where
  T: Sized,
  {
+ // SAFETY: the `arith_offset` intrinsic has no prerequisites to be called.
  unsafe { intrinsics::arith_offset(self, count) as *mut T }
  }
 
@@ -890,6 +889,7 @@ impl<T: ?Sized> *mut T {
  if !align.is_power_of_two() {
  panic!("align_offset: align is not a power-of-two");
  }
+ // SAFETY: `align` has been checked to be a power of 2 above
  unsafe { align_offset(self, align) }
  }
 }
@@ -917,6 +917,8 @@ impl<T> *mut [T] {
  #[unstable(feature = "slice_ptr_len", issue = "71146")]
  #[rustc_const_unstable(feature = "const_slice_ptr_len", issue = "71146")]
  pub const fn len(self) -> usize {
+ // SAFETY: this is safe because `*const [T]` and `FatPtr<T>` have the same layout.
+ // Only `std` can make this guarantee.
  unsafe { Repr { rust_mut: self }.raw }.len
  }
 }

src/librustc_ast/ast.rs

@@ -14,9 +14,9 @@
 //! - [`Generics`], [`GenericParam`], [`WhereClause`]: Metadata associated with generic parameters.
 //! - [`EnumDef`] and [`Variant`]: Enum declaration.
 //! - [`Lit`] and [`LitKind`]: Literal expressions.
-//! - [`MacroDef`], [`MacStmtStyle`], [`MacCall`], [`MacDelimeter`]: Macro definition and invocation.
+//! - [`MacroDef`], [`MacStmtStyle`], [`MacCall`], [`MacDelimiter`]: Macro definition and invocation.
 //! - [`Attribute`]: Metadata associated with item.
-//! - [`UnOp`], [`UnOpKind`], [`BinOp`], [`BinOpKind`]: Unary and binary operators.
+//! - [`UnOp`], [`BinOp`], and [`BinOpKind`]: Unary and binary operators.
 
 pub use crate::util::parser::ExprPrecedence;
 pub use GenericArgs::*;

src/librustc_infer/infer/at.rs

@@ -186,7 +186,6 @@ impl<'a, 'tcx> At<'a, 'tcx> {
 impl<'a, 'tcx> Trace<'a, 'tcx> {
  /// Makes `a <: b` where `a` may or may not be expected (if
  /// `a_is_expected` is true, then `a` is expected).
- /// Makes `expected <: actual`.
  pub fn sub<T>(self, a: &T, b: &T) -> InferResult<'tcx, ()>
  where
  T: Relate<'tcx>,

src/librustc_infer/infer/canonical/query_response.rs

@@ -16,7 +16,7 @@ use crate::infer::nll_relate::{NormalizationStrategy, TypeRelating, TypeRelating
 use crate::infer::region_constraints::{Constraint, RegionConstraintData};
 use crate::infer::{InferCtxt, InferOk, InferResult, NLLRegionVariableOrigin};
 use crate::traits::query::{Fallible, NoSolution};
-use crate::traits::{DomainGoal, TraitEngine};
+use crate::traits::TraitEngine;
 use crate::traits::{Obligation, ObligationCause, PredicateObligation};
 use rustc_data_structures::captures::Captures;
 use rustc_index::vec::Idx;
@@ -671,10 +671,6 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for QueryTypeRelatingDelegate<'_, 'tcx> {
  });
  }
 
- fn push_domain_goal(&mut self, _: DomainGoal<'tcx>) {
- bug!("should never be invoked with eager normalization")
- }
-
  fn normalization() -> NormalizationStrategy {
  NormalizationStrategy::Eager
  }

src/librustc_infer/infer/nll_relate/mod.rs

@@ -23,7 +23,6 @@
 
 use crate::infer::InferCtxt;
 use crate::infer::{ConstVarValue, ConstVariableValue};
-use crate::traits::DomainGoal;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::ty::error::TypeError;
 use rustc_middle::ty::fold::{TypeFoldable, TypeVisitor};
@@ -78,10 +77,6 @@ pub trait TypeRelatingDelegate<'tcx> {
  /// delegate.
  fn push_outlives(&mut self, sup: ty::Region<'tcx>, sub: ty::Region<'tcx>);
 
- /// Push a domain goal that will need to be proved for the two types to
- /// be related. Used for lazy normalization.
- fn push_domain_goal(&mut self, domain_goal: DomainGoal<'tcx>);
-
  /// Creates a new universe index. Used when instantiating placeholders.
  fn create_next_universe(&mut self) -> ty::UniverseIndex;
 
@@ -265,7 +260,6 @@ where
  value_ty: Ty<'tcx>,
  ) -> Ty<'tcx> {
  use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
- use crate::traits::WhereClause;
  use rustc_span::DUMMY_SP;
 
  match value_ty.kind {
@@ -279,12 +273,7 @@ where
  var
  }
 
- _ => {
- let projection = ty::ProjectionPredicate { projection_ty, ty: value_ty };
- self.delegate
- .push_domain_goal(DomainGoal::Holds(WhereClause::ProjectionEq(projection)));
- value_ty
- }
+ _ => bug!("should never be invoked with eager normalization"),
  }
  }
 

src/librustc_interface/passes.rs

@@ -838,10 +838,6 @@ fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
  tcx.par_body_owners(|def_id| tcx.ensure().mir_borrowck(def_id));
  });
 
- sess.time("dumping_chalk_like_clauses", || {
- rustc_traits::lowering::dump_program_clauses(tcx);
- });
-
  sess.time("MIR_effect_checking", || {
  for def_id in tcx.body_owners() {
  mir::transform::check_unsafety::check_unsafety(tcx, def_id.to_def_id())

src/librustc_middle/dep_graph/dep_node.rs

@@ -51,7 +51,6 @@
 
 use crate::mir;
 use crate::mir::interpret::{GlobalId, LitToConstInput};
-use crate::traits;
 use crate::traits::query::{
  CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
  CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,

src/librustc_middle/query/mod.rs

@@ -1,7 +1,6 @@
 use crate::dep_graph::SerializedDepNodeIndex;
 use crate::mir;
 use crate::mir::interpret::{GlobalId, LitToConstInput};
-use crate::traits;
 use crate::traits::query::{
  CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
  CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
@@ -224,19 +223,6 @@ rustc_queries! {
  anon
  desc { "erasing regions from `{:?}`", ty }
  }
-
- query program_clauses_for(_: DefId) -> Clauses<'tcx> {
- desc { "generating chalk-style clauses" }
- }
-
- query program_clauses_for_env(_: traits::Environment<'tcx>) -> Clauses<'tcx> {
- desc { "generating chalk-style clauses for environment" }
- }
-
- // Get the chalk-style environment of the given item.
- query environment(_: DefId) -> traits::Environment<'tcx> {
- desc { "return a chalk-style environment" }
- }
  }
 
  Linking {

src/librustc_middle/traits/mod.rs

@@ -9,7 +9,7 @@ mod structural_impls;
 
 use crate::mir::interpret::ErrorHandled;
 use crate::ty::subst::SubstsRef;
-use crate::ty::{self, AdtKind, List, Ty, TyCtxt};
+use crate::ty::{self, AdtKind, Ty, TyCtxt};
 
 use rustc_ast::ast;
 use rustc_hir as hir;
@@ -307,162 +307,6 @@ pub struct DerivedObligationCause<'tcx> {
  pub parent_code: Rc<ObligationCauseCode<'tcx>>,
 }
 
-/// The following types:
-/// * `WhereClause`,
-/// * `WellFormed`,
-/// * `FromEnv`,
-/// * `DomainGoal`,
-/// * `Goal`,
-/// * `Clause`,
-/// * `Environment`,
-/// * `InEnvironment`,
-/// are used for representing the trait system in the form of
-/// logic programming clauses. They are part of the interface
-/// for the chalk SLG solver.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable, Lift)]
-pub enum WhereClause<'tcx> {
- Implemented(ty::TraitPredicate<'tcx>),
- ProjectionEq(ty::ProjectionPredicate<'tcx>),
- RegionOutlives(ty::RegionOutlivesPredicate<'tcx>),
- TypeOutlives(ty::TypeOutlivesPredicate<'tcx>),
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable, Lift)]
-pub enum WellFormed<'tcx> {
- Trait(ty::TraitPredicate<'tcx>),
- Ty(Ty<'tcx>),
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable, Lift)]
-pub enum FromEnv<'tcx> {
- Trait(ty::TraitPredicate<'tcx>),
- Ty(Ty<'tcx>),
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable, Lift)]
-pub enum DomainGoal<'tcx> {
- Holds(WhereClause<'tcx>),
- WellFormed(WellFormed<'tcx>),
- FromEnv(FromEnv<'tcx>),
- Normalize(ty::ProjectionPredicate<'tcx>),
-}
-
-pub type PolyDomainGoal<'tcx> = ty::Binder<DomainGoal<'tcx>>;
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable)]
-pub enum QuantifierKind {
- Universal,
- Existential,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable, Lift)]
-pub enum GoalKind<'tcx> {
- Implies(Clauses<'tcx>, Goal<'tcx>),
- And(Goal<'tcx>, Goal<'tcx>),
- Not(Goal<'tcx>),
- DomainGoal(DomainGoal<'tcx>),
- Quantified(QuantifierKind, ty::Binder<Goal<'tcx>>),
- Subtype(Ty<'tcx>, Ty<'tcx>),
- CannotProve,
-}
-
-pub type Goal<'tcx> = &'tcx GoalKind<'tcx>;
-
-pub type Goals<'tcx> = &'tcx List<Goal<'tcx>>;
-
-impl<'tcx> DomainGoal<'tcx> {
- pub fn into_goal(self) -> GoalKind<'tcx> {
- GoalKind::DomainGoal(self)
- }
-
- pub fn into_program_clause(self) -> ProgramClause<'tcx> {
- ProgramClause {
- goal: self,
- hypotheses: ty::List::empty(),
- category: ProgramClauseCategory::Other,
- }
- }
-}
-
-impl<'tcx> GoalKind<'tcx> {
- pub fn from_poly_domain_goal(
- domain_goal: PolyDomainGoal<'tcx>,
- tcx: TyCtxt<'tcx>,
- ) -> GoalKind<'tcx> {
- match domain_goal.no_bound_vars() {
- Some(p) => p.into_goal(),
- None => GoalKind::Quantified(
- QuantifierKind::Universal,
- domain_goal.map_bound(|p| tcx.mk_goal(p.into_goal())),
- ),
- }
- }
-}
-
-/// This matches the definition from Page 7 of "A Proof Procedure for the Logic of Hereditary
-/// Harrop Formulas".
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable)]
-pub enum Clause<'tcx> {
- Implies(ProgramClause<'tcx>),
- ForAll(ty::Binder<ProgramClause<'tcx>>),
-}
-
-impl Clause<'tcx> {
- pub fn category(self) -> ProgramClauseCategory {
- match self {
- Clause::Implies(clause) => clause.category,
- Clause::ForAll(clause) => clause.skip_binder().category,
- }
- }
-}
-
-/// Multiple clauses.
-pub type Clauses<'tcx> = &'tcx List<Clause<'tcx>>;
-
-/// A "program clause" has the form `D :- G1, ..., Gn`. It is saying
-/// that the domain goal `D` is true if `G1...Gn` are provable. This
-/// is equivalent to the implication `G1..Gn => D`; we usually write
-/// it with the reverse implication operator `:-` to emphasize the way
-/// that programs are actually solved (via backchaining, which starts
-/// with the goal to solve and proceeds from there).
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable)]
-pub struct ProgramClause<'tcx> {
- /// This goal will be considered true ...
- pub goal: DomainGoal<'tcx>,
-
- /// ... if we can prove these hypotheses (there may be no hypotheses at all):
- pub hypotheses: Goals<'tcx>,
-
- /// Useful for filtering clauses.
- pub category: ProgramClauseCategory,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable)]
-pub enum ProgramClauseCategory {
- ImpliedBound,
- WellFormed,
- Other,
-}
-
-/// A set of clauses that we assume to be true.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable)]
-pub struct Environment<'tcx> {
- pub clauses: Clauses<'tcx>,
-}
-
-impl Environment<'tcx> {
- pub fn with<G>(self, goal: G) -> InEnvironment<'tcx, G> {
- InEnvironment { environment: self, goal }
- }
-}
-
-/// Something (usually a goal), along with an environment.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable, TypeFoldable)]
-pub struct InEnvironment<'tcx, G> {
- pub environment: Environment<'tcx>,
- pub goal: G,
-}
-
 #[derive(Clone, Debug, TypeFoldable)]
 pub enum SelectionError<'tcx> {
  Unimplemented,