remove typeof support

Author: lcnr

compiler/rustc_ast/src/ast.rs

@@ -2488,8 +2488,6 @@ pub enum TyKind {
  ImplTrait(NodeId, #[visitable(extra = BoundKind::Impl)] GenericBounds),
  /// No-op; kept solely so that we can pretty-print faithfully.
  Paren(Box<Ty>),
- /// Unused for now.
- Typeof(AnonConst),
  /// This means the type should be inferred instead of it having been
  /// specified. This can appear anywhere in a type.
  Infer,

compiler/rustc_ast/src/token.rs

@@ -321,7 +321,7 @@ fn ident_can_begin_type(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
 
  !ident_token.is_reserved_ident()
  || ident_token.is_path_segment_keyword()
- || [kw::Underscore, kw::For, kw::Impl, kw::Fn, kw::Unsafe, kw::Extern, kw::Typeof, kw::Dyn]
+ || [kw::Underscore, kw::For, kw::Impl, kw::Fn, kw::Unsafe, kw::Extern, kw::Dyn]
  .contains(&name)
 }
 

compiler/rustc_ast/src/util/classify.rs

@@ -294,7 +294,6 @@ fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
  | ast::TyKind::Never
  | ast::TyKind::Tup(..)
  | ast::TyKind::Paren(..)
- | ast::TyKind::Typeof(..)
  | ast::TyKind::Infer
  | ast::TyKind::ImplicitSelf
  | ast::TyKind::CVarArgs

compiler/rustc_ast_lowering/src/lib.rs

@@ -1361,7 +1361,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  self.lower_ty(ty, itctx),
  self.lower_array_length_to_const_arg(length),
  ),
- TyKind::Typeof(expr) => hir::TyKind::Typeof(self.lower_anon_const_to_anon_const(expr)),
  TyKind::TraitObject(bounds, kind) => {
  let mut lifetime_bound = None;
  let (bounds, lifetime_bound) = self.with_dyn_type_scope(true, |this| {

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1325,11 +1325,6 @@ impl<'a> State<'a> {
  self.print_expr(&length.value, FixupContext::default());
  self.word("]");
  }
- ast::TyKind::Typeof(e) => {
- self.word("typeof(");
- self.print_expr(&e.value, FixupContext::default());
- self.word(")");
- }
  ast::TyKind::Infer => {
  self.word("_");
  }

compiler/rustc_error_codes/src/error_codes/E0516.md

@@ -1,3 +1,5 @@
+#### Note: this error code is no longer emitted by the compiler.
+
 The `typeof` keyword is currently reserved but unimplemented.
 
 Erroneous code example:

compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs

@@ -195,10 +195,11 @@ impl<'tcx> InherentCollect<'tcx> {
  | ty::Closure(..)
  | ty::CoroutineClosure(..)
  | ty::Coroutine(..)
- | ty::CoroutineWitness(..) => {
- Err(self.tcx.dcx().delayed_bug("cannot define inherent `impl` for closure types"))
- }
- ty::Alias(ty::Free, _) | ty::Bound(..) | ty::Placeholder(_) | ty::Infer(_) => {
+ | ty::CoroutineWitness(..)
+ | ty::Alias(ty::Free, _)
+ | ty::Bound(..)
+ | ty::Placeholder(_)
+ | ty::Infer(_) => {
  bug!("unexpected impl self type of impl: {:?} {:?}", id, self_ty);
  }
  // We could bail out here, but that will silence other useful errors.

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -217,21 +217,19 @@ pub(crate) fn orphan_check_impl(
  | ty::Slice(..)
  | ty::RawPtr(..)
  | ty::Ref(..)
- | ty::FnDef(..)
  | ty::FnPtr(..)
  | ty::Never
  | ty::Tuple(..)
  | ty::UnsafeBinder(_) => (LocalImpl::Allow, NonlocalImpl::DisallowOther),
 
- ty::Closure(..)
+ ty::FnDef(..)
+ | ty::Closure(..)
  | ty::CoroutineClosure(..)
  | ty::Coroutine(..)
- | ty::CoroutineWitness(..) => {
- return Err(tcx
- .dcx()
- .delayed_bug("cannot define inherent `impl` for closure types"));
- }
- ty::Bound(..) | ty::Placeholder(..) | ty::Infer(..) => {
+ | ty::CoroutineWitness(..)
+ | ty::Bound(..)
+ | ty::Placeholder(..)
+ | ty::Infer(..) => {
  let sp = tcx.def_span(impl_def_id);
  span_bug!(sp, "weird self type for autotrait impl")
  }

compiler/rustc_lint/src/unused.rs

@@ -1644,18 +1644,6 @@ impl EarlyLintPass for UnusedBraces {
  );
  }
 
- ast::TyKind::Typeof(ref anon_const) => {
- self.check_unused_delims_expr(
- cx,
- &anon_const.value,
- UnusedDelimsCtx::AnonConst,
- false,
- None,
- None,
- false,
- );
- }
-
  _ => {}
  }
  }

compiler/rustc_next_trait_solver/src/coherence.rs

@@ -336,7 +336,6 @@ where
  | ty::Uint(..)
  | ty::Float(..)
  | ty::Str
- | ty::FnDef(..)
  | ty::Pat(..)
  | ty::FnPtr(..)
  | ty::Array(..)
@@ -403,7 +402,6 @@ where
  // implement, so we don't use this behavior.
  // Addendum: Moreover, revealing the underlying type is likely to cause cycle
  // errors as we rely on coherence / the specialization graph during typeck.
-
  self.found_non_local_ty(ty)
  }
  }
@@ -435,31 +433,14 @@ where
  }
  }
  ty::Error(_) => ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty)),
- ty::Closure(did, ..) => {
- if self.def_id_is_local(did) {
- ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
- } else {
- self.found_non_local_ty(ty)
- }
- }
- ty::CoroutineClosure(did, ..) => {
- if self.def_id_is_local(did) {
- ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
- } else {
- self.found_non_local_ty(ty)
- }
- }
- ty::Coroutine(did, ..) => {
- if self.def_id_is_local(did) {
- ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
- } else {
- self.found_non_local_ty(ty)
- }
+
+ ty::FnDef(..)
+ | ty::Closure(..)
+ | ty::CoroutineClosure(..)
+ | ty::Coroutine(..)
+ | ty::CoroutineWitness(..) => {
+ unreachable!("unnameable type in coherence: {ty:?}");
  }
- // This should only be created when checking whether we have to check whether some
- // auto trait impl applies. There will never be multiple impls, so we can just
- // act as if it were a local type here.
- ty::CoroutineWitness(..) => ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty)),
  };
  // A bit of a hack, the `OrphanChecker` is only used to visit a `TraitRef`, so
  // the first type we visit is always the self type.