Add internal lint against Ty == Ty

This operation does not do what people usually want. Also check against
other comparison operators since they are just as sketchy.

Allow the `ty_eq_operator` lint for now until the next bootstrap bump

compiler/rustc_lint/messages.ftl

@@ -505,6 +505,13 @@ lint_suspicious_double_ref_deref =
 
 lint_trivial_untranslatable_diag = diagnostic with static strings only
 
+
+lint_ty_compare_operator_used = using the a comparison operator on `Ty`
+ .note = this does probably not what you want as it does not handle inference variables and more
+ .help = for more information, see https://rustc-dev-guide.rust-lang.org/ty.html#comparing-types
+
+lint_ty_no_compare_operator_for_diagnostics = it's also not recommended to use it for diagnostics
+
 lint_ty_qualified = usage of qualified `ty::{$ty}`
  .suggestion = try importing it and using it unqualified
 

compiler/rustc_lint/src/internal.rs

@@ -3,11 +3,12 @@
 
 use crate::lints::{
  BadOptAccessDiag, DefaultHashTypesDiag, DiagOutOfImpl, LintPassByHand, NonExistentDocKeyword,
- QueryInstability, TyQualified, TykindDiag, TykindKind, UntranslatableDiag,
- UntranslatableDiagnosticTrivial,
+ QueryInstability, TyCompareOperatorUsed, TyQualified, TykindDiag, TykindKind,
+ UntranslatableDiag, UntranslatableDiagnosticTrivial,
 };
 use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_ast as ast;
+use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::{def_id::DefId, Expr, ExprKind, GenericArg, PatKind, Path, PathSegment, QPath};
 use rustc_hir::{HirId, Impl, Item, ItemKind, Node, Pat, Ty, TyKind};
@@ -127,12 +128,7 @@ declare_lint_pass!(TyTyKind => [
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for TyTyKind {
- fn check_path(
- &mut self,
- cx: &LateContext<'tcx>,
- path: &rustc_hir::Path<'tcx>,
- _: rustc_hir::HirId,
- ) {
+ fn check_path(&mut self, cx: &LateContext<'tcx>, path: &hir::Path<'tcx>, _: hir::HirId) {
  if let Some(segment) = path.segments.iter().nth_back(1)
  && lint_ty_kind_usage(cx, &segment.res)
  {
@@ -269,6 +265,37 @@ fn gen_args(segment: &PathSegment<'_>) -> String {
  String::new()
 }
 
+declare_tool_lint! {
+ pub rustc::TY_COMPARE_OPERATOR,
+ Allow,
+ "using the a comparison operator on `Ty`"
+}
+
+declare_lint_pass!(TyCompareOperator => [TY_COMPARE_OPERATOR]);
+
+impl<'tcx> LateLintPass<'tcx> for TyCompareOperator {
+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
+ use hir::BinOpKind::*;
+
+ if let hir::ExprKind::Binary(
+ hir::BinOp { node:Eq | Ne | Gt | Lt | Le | Ge, span},
+ lhs,
+ rhs
+ ) = expr.kind
+ && let ty::Adt(lhs_def, _) = cx.typeck_results().node_type(lhs.hir_id).peel_refs().kind()
+ && let ty::Adt(rhs_def, _) = cx.typeck_results().node_type(rhs.hir_id).peel_refs().kind()
+ && cx.tcx.is_diagnostic_item(sym::Ty, lhs_def.did())
+ && cx.tcx.is_diagnostic_item(sym::Ty, rhs_def.did())
+ {
+ cx.emit_spanned_lint(
+ TY_COMPARE_OPERATOR,
+ span,
+ TyCompareOperatorUsed,
+ )
+ }
+ }
+}
+
 declare_tool_lint! {
  /// The `lint_pass_impl_without_macro` detects manual implementations of a lint
  /// pass, without using [`declare_lint_pass`] or [`impl_lint_pass`].
@@ -318,7 +345,7 @@ fn is_doc_keyword(s: Symbol) -> bool {
 }
 
 impl<'tcx> LateLintPass<'tcx> for ExistingDocKeyword {
- fn check_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::Item<'_>) {
+ fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
  for attr in cx.tcx.hir().attrs(item.hir_id()) {
  if !attr.has_name(sym::doc) {
  continue;

compiler/rustc_lint/src/lib.rs

@@ -524,6 +524,8 @@ fn register_internals(store: &mut LintStore) {
  store.register_late_mod_pass(|_| Box::new(ExistingDocKeyword));
  store.register_lints(&TyTyKind::get_lints());
  store.register_late_mod_pass(|_| Box::new(TyTyKind));
+ store.register_lints(&TyCompareOperator::get_lints());
+ store.register_late_mod_pass(|_| Box::new(TyCompareOperator));
  store.register_lints(&Diagnostics::get_lints());
  store.register_early_pass(|| Box::new(Diagnostics));
  store.register_late_mod_pass(|_| Box::new(Diagnostics));
@@ -543,6 +545,7 @@ fn register_internals(store: &mut LintStore) {
  LintId::of(DEFAULT_HASH_TYPES),
  LintId::of(POTENTIAL_QUERY_INSTABILITY),
  LintId::of(USAGE_OF_TY_TYKIND),
+ LintId::of(TY_COMPARE_OPERATOR),
  LintId::of(PASS_BY_VALUE),
  LintId::of(LINT_PASS_IMPL_WITHOUT_MACRO),
  LintId::of(USAGE_OF_QUALIFIED_TY),

compiler/rustc_lint/src/lints.rs

@@ -920,6 +920,13 @@ pub struct TyQualified {
  pub suggestion: Span,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_ty_compare_operator_used)]
+#[note]
+#[note(lint_ty_no_compare_operator_for_diagnostics)]
+#[help]
+pub struct TyCompareOperatorUsed;
+
 #[derive(LintDiagnostic)]
 #[diag(lint_lintpass_by_hand)]
 #[help]

src/bootstrap/builder.rs

@@ -1878,9 +1878,16 @@ impl<'a> Builder<'a> {
  rustdocflags.arg("-Wrustdoc::invalid_codeblock_attributes");
  }
 
- if mode == Mode::Rustc {
+ if mode == Mode::Rustc || mode == Mode::ToolRustc {
  rustflags.arg("-Zunstable-options");
  rustflags.arg("-Wrustc::internal");
+
+ // #[cfg(not(bootstrap))]
+ if stage != 0 {
+ // FIXME(Nilstrieb): Allow this lint for now.
+ // After it's in beta, we can start work on fixing it.
+ rustflags.arg("-Arustc::ty-compare-operator");
+ }
  }
 
  // Throughout the build Cargo can execute a number of build scripts

tests/ui/lint/internal/ty_compare_operator.rs

@@ -0,0 +1,37 @@
+// compile-flags: -Z unstable-options
+
+#![feature(rustc_attrs)]
+#![forbid(rustc::ty_compare_operator)]
+
+mod ty1 {
+ #[derive(PartialEq, PartialOrd)]
+ #[rustc_diagnostic_item = "Ty"]
+ pub struct Ty;
+}
+
+mod ty2 {
+ #[derive(PartialEq, PartialOrd)]
+ pub struct Ty;
+}
+
+fn main() {
+ let _ = ty1::Ty == ty1::Ty;
+ //~^ ERROR using the a comparison operator on `Ty`
+ let _ = ty1::Ty != ty1::Ty;
+ //~^ ERROR using the a comparison operator on `Ty`
+ let _ = ty1::Ty < ty1::Ty;
+ //~^ ERROR using the a comparison operator on `Ty`
+ let _ = ty1::Ty <= ty1::Ty;
+ //~^ ERROR using the a comparison operator on `Ty`
+ let _ = ty1::Ty > ty1::Ty;
+ //~^ ERROR using the a comparison operator on `Ty`
+ let _ = ty1::Ty >= ty1::Ty;
+ //~^ ERROR using the a comparison operator on `Ty`
+
+ let _ = ty2::Ty == ty2::Ty;
+ let _ = ty2::Ty != ty2::Ty;
+ let _ = ty2::Ty < ty2::Ty;
+ let _ = ty2::Ty <= ty2::Ty;
+ let _ = ty2::Ty > ty2::Ty;
+ let _ = ty2::Ty >= ty2::Ty;
+}

tests/ui/lint/internal/ty_compare_operator.stderr

@@ -0,0 +1,67 @@
+error: using the a comparison operator on `Ty`
+ --> $DIR/ty_compare_operator.rs:18:21
+ |
+LL | let _ = ty1::Ty == ty1::Ty;
+ | ^^
+ |
+ = note: this does probably not what you want as it does not handle inference variables and more
+ = note: it's also not recommended to use it for diagnostics
+ = help: for more information, see https://rustc-dev-guide.rust-lang.org/ty.html#comparing-types
+note: the lint level is defined here
+ --> $DIR/ty_compare_operator.rs:4:11
+ |
+LL | #![forbid(rustc::ty_compare_operator)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: using the a comparison operator on `Ty`
+ --> $DIR/ty_compare_operator.rs:20:21
+ |
+LL | let _ = ty1::Ty != ty1::Ty;
+ | ^^
+ |
+ = note: this does probably not what you want as it does not handle inference variables and more
+ = note: it's also not recommended to use it for diagnostics
+ = help: for more information, see https://rustc-dev-guide.rust-lang.org/ty.html#comparing-types
+
+error: using the a comparison operator on `Ty`
+ --> $DIR/ty_compare_operator.rs:22:21
+ |
+LL | let _ = ty1::Ty < ty1::Ty;
+ | ^
+ |
+ = note: this does probably not what you want as it does not handle inference variables and more
+ = note: it's also not recommended to use it for diagnostics
+ = help: for more information, see https://rustc-dev-guide.rust-lang.org/ty.html#comparing-types
+
+error: using the a comparison operator on `Ty`
+ --> $DIR/ty_compare_operator.rs:24:21
+ |
+LL | let _ = ty1::Ty <= ty1::Ty;
+ | ^^
+ |
+ = note: this does probably not what you want as it does not handle inference variables and more
+ = note: it's also not recommended to use it for diagnostics
+ = help: for more information, see https://rustc-dev-guide.rust-lang.org/ty.html#comparing-types
+
+error: using the a comparison operator on `Ty`
+ --> $DIR/ty_compare_operator.rs:26:21
+ |
+LL | let _ = ty1::Ty > ty1::Ty;
+ | ^
+ |
+ = note: this does probably not what you want as it does not handle inference variables and more
+ = note: it's also not recommended to use it for diagnostics
+ = help: for more information, see https://rustc-dev-guide.rust-lang.org/ty.html#comparing-types
+
+error: using the a comparison operator on `Ty`
+ --> $DIR/ty_compare_operator.rs:28:21
+ |
+LL | let _ = ty1::Ty >= ty1::Ty;
+ | ^^
+ |
+ = note: this does probably not what you want as it does not handle inference variables and more
+ = note: it's also not recommended to use it for diagnostics
+ = help: for more information, see https://rustc-dev-guide.rust-lang.org/ty.html#comparing-types
+
+error: aborting due to 6 previous errors
+