Exhaustively handle expressions in patterns

Author: oli-obk

compiler/rustc_ast_lowering/src/expr.rs

@@ -102,17 +102,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
 let kind = match&e.kind{
 ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
-ExprKind::ConstBlock(c) => {
-let c = self.with_new_scopes(c.value.span, |this| {
-let def_id = this.local_def_id(c.id);
- hir::ConstBlock{
- def_id,
-hir_id: this.lower_node_id(c.id),
-body: this.lower_const_body(c.value.span,Some(&c.value)),
-}
-});
- hir::ExprKind::ConstBlock(c)
-}
+ExprKind::ConstBlock(c) => hir::ExprKind::ConstBlock(self.lower_const_block(c)),
 ExprKind::Repeat(expr, count) => {
 let expr = self.lower_expr(expr);
 let count = self.lower_array_length_to_const_arg(count);
@@ -153,18 +143,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 let ohs = self.lower_expr(ohs);
  hir::ExprKind::Unary(op, ohs)
 }
-ExprKind::Lit(token_lit) => {
-let lit_kind = matchLitKind::from_token_lit(*token_lit){
-Ok(lit_kind) => lit_kind,
-Err(err) => {
-let guar =
-report_lit_error(&self.tcx.sess.psess, err,*token_lit, e.span);
-LitKind::Err(guar)
-}
-};
-let lit = self.arena.alloc(respan(self.lower_span(e.span), lit_kind));
- hir::ExprKind::Lit(lit)
-}
+ExprKind::Lit(token_lit) => hir::ExprKind::Lit(self.lower_lit(token_lit, e.span)),
 ExprKind::IncludedBytes(bytes) => {
 let lit = self.arena.alloc(respan(
 self.lower_span(e.span),
@@ -403,6 +382,32 @@ impl<'hir> LoweringContext<'_, 'hir> {
 })
 }
 
+pub(crate)fnlower_const_block(&mutself,c:&AnonConst) -> hir::ConstBlock{
+self.with_new_scopes(c.value.span, |this| {
+let def_id = this.local_def_id(c.id);
+ hir::ConstBlock{
+ def_id,
+hir_id: this.lower_node_id(c.id),
+body: this.lower_const_body(c.value.span,Some(&c.value)),
+}
+})
+}
+
+pub(crate)fnlower_lit(
+&mutself,
+token_lit:&token::Lit,
+span:Span,
+) -> &'hirSpanned<LitKind>{
+let lit_kind = matchLitKind::from_token_lit(*token_lit){
+Ok(lit_kind) => lit_kind,
+Err(err) => {
+let guar = report_lit_error(&self.tcx.sess.psess, err,*token_lit, span);
+LitKind::Err(guar)
+}
+};
+self.arena.alloc(respan(self.lower_span(span), lit_kind))
+}
+
 fnlower_unop(&mutself,u:UnOp) -> hir::UnOp{
 match u {
 UnOp::Deref => hir::UnOp::Deref,

compiler/rustc_ast_lowering/src/index.rs

@@ -209,6 +209,14 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
 });
 }
 
+fnvisit_pat_expr(&mutself,expr:&'hirPatExpr<'hir>){
+self.insert(expr.span, expr.hir_id,Node::PatExpr(expr));
+
+self.with_parent(expr.hir_id, |this| {
+ intravisit::walk_pat_expr(this, expr);
+});
+}
+
 fnvisit_pat_field(&mutself,field:&'hirPatField<'hir>){
 self.insert(field.span, field.hir_id,Node::PatField(field));
 self.with_parent(field.hir_id, |this| {

compiler/rustc_ast_lowering/src/lib.rs

@@ -35,6 +35,7 @@
 #![doc(rust_logo)]
 #![feature(assert_matches)]
 #![feature(box_patterns)]
+#![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
 #![warn(unreachable_pub)]

compiler/rustc_ast_lowering/src/pat.rs

@@ -1,9 +1,12 @@
+use std::sync::Arc;
+
 use rustc_ast::ptr::P;
 use rustc_ast::*;
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir as hir;
 use rustc_hir::def::Res;
-use rustc_span::source_map::Spanned;
+use rustc_middle::span_bug;
+use rustc_span::source_map::{Spanned, respan};
 use rustc_span::{Ident,Span};
 
 usesuper::errors::{
@@ -367,24 +370,54 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 // }
 // m!(S);
 // ```
-fnlower_expr_within_pat(&mutself,expr:&Expr,allow_paths:bool) -> &'hir hir::Expr<'hir>{
-match&expr.kind{
-ExprKind::Lit(..)
- | ExprKind::ConstBlock(..)
- | ExprKind::IncludedBytes(..)
- | ExprKind::Err(_)
- | ExprKind::Dummy => {}
-ExprKind::Path(..)if allow_paths => {}
-ExprKind::Unary(UnOp::Neg, inner)ifmatches!(inner.kind,ExprKind::Lit(_)) => {}
+fnlower_expr_within_pat(
+&mutself,
+expr:&Expr,
+allow_paths:bool,
+) -> &'hir hir::PatExpr<'hir>{
+let err = |guar| hir::PatExprKind::Lit{
+lit:self.arena.alloc(respan(self.lower_span(expr.span),LitKind::Err(guar))),
+negated:false,
+};
+let kind = match&expr.kind{
+ExprKind::Lit(lit) => {
+ hir::PatExprKind::Lit{lit:self.lower_lit(lit, expr.span),negated:false}
+}
+ExprKind::ConstBlock(c) => hir::PatExprKind::ConstBlock(self.lower_const_block(c)),
+ExprKind::IncludedBytes(bytes) => hir::PatExprKind::Lit{
+lit:self.arena.alloc(respan(
+self.lower_span(expr.span),
+LitKind::ByteStr(Arc::clone(bytes),StrStyle::Cooked),
+)),
+negated:false,
+},
+ExprKind::Err(guar) => err(*guar),
+ExprKind::Dummy => span_bug!(expr.span,"lowered ExprKind::Dummy"),
+ExprKind::Path(qself, path)if allow_paths => hir::PatExprKind::Path(self.lower_qpath(
+ expr.id,
+ qself,
+ path,
+ParamMode::Optional,
+AllowReturnTypeNotation::No,
+ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+None,
+)),
+ExprKind::Unary(UnOp::Neg, inner)ifletExprKind::Lit(lit) = &inner.kind => {
+ hir::PatExprKind::Lit{lit:self.lower_lit(lit, expr.span),negated:true}
+}
  _ => {
 let pattern_from_macro = expr.is_approximately_pattern();
 let guar = self.dcx().emit_err(ArbitraryExpressionInPattern{
 span: expr.span,
 pattern_from_macro_note: pattern_from_macro,
 });
-returnself.arena.alloc(self.expr_err(expr.span,guar));
+err(guar)
 }
-}
-self.lower_expr(expr)
+};
+self.arena.alloc(hir::PatExpr{
+hir_id:self.lower_node_id(expr.id),
+span: expr.span,
+ kind,
+})
 }
 }

compiler/rustc_hir/src/hir.rs

@@ -1519,6 +1519,26 @@ impl fmt::Debug for DotDotPos {
 }
 }
 
+#[derive(Debug,Clone,Copy,HashStable_Generic)]
+pubstructPatExpr<'hir>{
+pubhir_id:HirId,
+pubspan:Span,
+pubkind:PatExprKind<'hir>,
+}
+
+#[derive(Debug,Clone,Copy,HashStable_Generic)]
+pubenumPatExprKind<'hir>{
+Lit{
+lit:&'hirLit,
+// FIXME: move this into `Lit` and handle negated literal expressions
+// once instead of matching on unop neg expressions everywhere.
+negated:bool,
+},
+ConstBlock(ConstBlock),
+/// A path pattern for a unit struct/variant or a (maybe-associated) constant.
+Path(QPath<'hir>),
+}
+
 #[derive(Debug,Clone,Copy,HashStable_Generic)]
 pubenumPatKind<'hir>{
 /// Represents a wildcard pattern (i.e., `_`).
@@ -1564,13 +1584,13 @@ pub enum PatKind<'hir> {
 Ref(&'hirPat<'hir>,Mutability),
 
 /// A literal.
-Lit(&'hirExpr<'hir>),
+Lit(&'hirPatExpr<'hir>),
 
 /// A guard pattern (e.g., `x if guard(x)`).
 Guard(&'hirPat<'hir>,&'hirExpr<'hir>),
 
 /// A range pattern (e.g., `1..=2` or `1..2`).
-Range(Option<&'hirExpr<'hir>>,Option<&'hirExpr<'hir>>,RangeEnd),
+Range(Option<&'hirPatExpr<'hir>>,Option<&'hirPatExpr<'hir>>,RangeEnd),
 
 /// A slice pattern, `[before_0, ..., before_n, (slice, after_0, ..., after_n)?]`.
 ///
@@ -4144,6 +4164,10 @@ pub enum Node<'hir> {
 OpaqueTy(&'hirOpaqueTy<'hir>),
 Pat(&'hirPat<'hir>),
 PatField(&'hirPatField<'hir>),
+/// Needed as its own node with its own HirId for tracking
+/// the unadjusted type of literals within patterns
+/// (e.g. byte str literals not being of slice type).
+PatExpr(&'hirPatExpr<'hir>),
 Arm(&'hirArm<'hir>),
 Block(&'hirBlock<'hir>),
 LetStmt(&'hirLetStmt<'hir>),
@@ -4200,6 +4224,7 @@ impl<'hir> Node<'hir> {
  | Node::Block(..)
  | Node::Ctor(..)
  | Node::Pat(..)
+ | Node::PatExpr(..)
  | Node::Arm(..)
  | Node::LetStmt(..)
  | Node::Crate(..)

compiler/rustc_hir/src/intravisit.rs

@@ -342,6 +342,9 @@ pub trait Visitor<'v>: Sized {
 fnvisit_pat_field(&mutself,f:&'vPatField<'v>) -> Self::Result{
 walk_pat_field(self, f)
 }
+fnvisit_pat_expr(&mutself,expr:&'vPatExpr<'v>) -> Self::Result{
+walk_pat_expr(self, expr)
+}
 fnvisit_anon_const(&mutself,c:&'vAnonConst) -> Self::Result{
 walk_anon_const(self, c)
 }
@@ -685,10 +688,10 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat<'v>) -> V:
 try_visit!(visitor.visit_ident(ident));
 visit_opt!(visitor, visit_pat, optional_subpattern);
 }
-PatKind::Lit(ref expression) => try_visit!(visitor.visit_expr(expression)),
+PatKind::Lit(ref expression) => try_visit!(visitor.visit_pat_expr(expression)),
 PatKind::Range(ref lower_bound,ref upper_bound, _) => {
-visit_opt!(visitor,visit_expr, lower_bound);
-visit_opt!(visitor,visit_expr, upper_bound);
+visit_opt!(visitor,visit_pat_expr, lower_bound);
+visit_opt!(visitor,visit_pat_expr, upper_bound);
 }
 PatKind::Never | PatKind::Wild | PatKind::Err(_) => (),
 PatKind::Slice(prepatterns,ref slice_pattern, postpatterns) => {
@@ -710,6 +713,15 @@ pub fn walk_pat_field<'v, V: Visitor<'v>>(visitor: &mut V, field: &'v PatField<'
  visitor.visit_pat(field.pat)
 }
 
+pubfnwalk_pat_expr<'v,V:Visitor<'v>>(visitor:&mutV,expr:&'vPatExpr<'v>) -> V::Result{
+try_visit!(visitor.visit_id(expr.hir_id));
+match&expr.kind{
+PatExprKind::Lit{ .. } => V::Result::output(),
+PatExprKind::ConstBlock(c) => visitor.visit_inline_const(c),
+PatExprKind::Path(qpath) => visitor.visit_qpath(qpath, expr.hir_id, expr.span),
+}
+}
+
 pubfnwalk_anon_const<'v,V:Visitor<'v>>(visitor:&mutV,constant:&'vAnonConst) -> V::Result{
 try_visit!(visitor.visit_id(constant.hir_id));
  visitor.visit_nested_body(constant.body)

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2449,17 +2449,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 Ty::new_error(tcx, err)
 }
  hir::PatKind::Range(start, end, include_end) => {
-let expr_to_const = |expr:&'tcx hir::Expr<'tcx>| -> ty::Const<'tcx>{
-let(expr, neg) = match expr.kind{
- hir::ExprKind::Unary(hir::UnOp::Neg, negated) => {
-(negated,Some((expr.hir_id, expr.span)))
-}
- _ => (expr,None),
-};
-let(c, c_ty) = match&expr.kind{
- hir::ExprKind::Lit(lit) => {
+let expr_to_const = |expr:&'tcx hir::PatExpr<'tcx>| -> ty::Const<'tcx>{
+let(c, c_ty) = match expr.kind{
+ hir::PatExprKind::Lit{ lit, negated } => {
 let lit_input =
-LitToConstInput{lit:&lit.node, ty,neg:neg.is_some()};
+LitToConstInput{lit:&lit.node, ty,neg:negated};
 let ct = match tcx.lit_to_const(lit_input){
 Ok(c) => c,
 Err(LitToConstError::Reported(err)) => {
@@ -2470,23 +2464,30 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 (ct, ty)
 }
 
- hir::ExprKind::Path(hir::QPath::Resolved(
+ hir::PatExprKind::Path(hir::QPath::Resolved(
  _,
  path @ &hir::Path{
 res:Res::Def(DefKind::ConstParam, def_id),
  ..
 },
 )) => {
-let _ =self.prohibit_generic_args(
+matchself.prohibit_generic_args(
  path.segments.iter(),
 GenericsArgsErrExtend::Param(def_id),
-);
-let ty = tcx
-.type_of(def_id)
-.no_bound_vars()
-.expect("const parameter types cannot be generic");
-let ct = self.lower_const_param(def_id, expr.hir_id);
-(ct, ty)
+){
+Ok(()) => {
+let ty = tcx
+.type_of(def_id)
+.no_bound_vars()
+.expect("const parameter types cannot be generic");
+let ct = self.lower_const_param(def_id, expr.hir_id);
+(ct, ty)
+}
+Err(guar) => (
+ ty::Const::new_error(tcx, guar),
+Ty::new_error(tcx, guar),
+),
+}
 }
 
  _ => {
@@ -2497,9 +2498,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 }
 };
 self.record_ty(expr.hir_id, c_ty, expr.span);
-ifletSome((id, span)) = neg {
-self.record_ty(id, c_ty, span);
-}
  c
 };
 

compiler/rustc_hir_pretty/src/lib.rs

@@ -199,6 +199,7 @@ impl<'a> State<'a> {
 Node::OpaqueTy(o) => self.print_opaque_ty(o),
 Node::Pat(a) => self.print_pat(a),
 Node::PatField(a) => self.print_patfield(a),
+Node::PatExpr(a) => self.print_pat_expr(a),
 Node::Arm(a) => self.print_arm(a),
 Node::Infer(_) => self.word("_"),
 Node::PreciseCapturingNonLifetimeArg(param) => self.print_ident(param.ident),
@@ -1849,6 +1850,19 @@ impl<'a> State<'a> {
 }
 }
 
+fnprint_pat_expr(&mutself,expr:&hir::PatExpr<'_>){
+match&expr.kind{
+ hir::PatExprKind::Lit{ lit, negated } => {
+if*negated {
+self.word("-");
+}
+self.print_literal(lit);
+}
+ hir::PatExprKind::ConstBlock(c) => self.print_inline_const(c),
+ hir::PatExprKind::Path(qpath) => self.print_qpath(qpath,true),
+}
+}
+
 fnprint_pat(&mutself,pat:&hir::Pat<'_>){
 self.maybe_print_comment(pat.span.lo());
 self.ann.pre(self,AnnNode::Pat(pat));
@@ -1966,17 +1980,17 @@ impl<'a> State<'a> {
 self.pclose();
 }
 }
-PatKind::Lit(e) => self.print_expr(e),
+PatKind::Lit(e) => self.print_pat_expr(e),
 PatKind::Range(begin, end, end_kind) => {
 ifletSome(expr) = begin {
-self.print_expr(expr);
+self.print_pat_expr(expr);
 }
 match end_kind {
 RangeEnd::Included => self.word("..."),
 RangeEnd::Excluded => self.word(".."),
 }
 ifletSome(expr) = end {
-self.print_expr(expr);
+self.print_pat_expr(expr);
 }
 }
 PatKind::Slice(before, slice, after) => {