@@ -65,6 +65,8 @@ enum IsRepeatExpr {
6565 Yes ,
6666}
6767
68+ struct IsNeverPattern ;
69+
6870/// Describes whether an `AnonConst` is a type level const arg or
6971/// some other form of anon const (i.e. inline consts or enum discriminants)
7072#[ derive( Copy , Clone , Debug , PartialEq , Eq ) ]
@@ -3190,12 +3192,16 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
31903192 self . resolve_pattern_top ( & local. pat , PatternSource :: Let ) ;
31913193 }
31923194
3193- /// build a map from pattern identifiers to binding-info's.
3194- /// this is done hygienically. This could arise for a macro
3195- /// that expands into an or-pattern where one 'x' was from the
3196- /// user and one 'x' came from the macro.
3197- fn binding_mode_map ( & mut self , pat : & Pat ) -> FxIndexMap < Ident , BindingInfo > {
3195+ /// Build a map from pattern identifiers to binding-info's, and check the bindings are
3196+ /// consistent when encountering or-patterns and never patterns.
3197+ /// This is done hygienically: this could arise for a macro that expands into an or-pattern
3198+ /// where one 'x' was from the user and one 'x' came from the macro.
3199+ fn compute_and_check_binding_map (
3200+ & mut self ,
3201+ pat : & Pat ,
3202+ ) -> Result < FxIndexMap < Ident , BindingInfo > , IsNeverPattern > {
31983203 let mut binding_map = FxIndexMap :: default ( ) ;
3204+ let mut is_never_pat = false ;
31993205
32003206 pat. walk ( & mut |pat| {
32013207 match pat. kind {
@@ -3207,18 +3213,26 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
32073213 PatKind :: Or ( ref ps) => {
32083214 // Check the consistency of this or-pattern and
32093215 // then add all bindings to the larger map.
3210- for bm in self . check_consistent_bindings ( ps) {
3211- binding_map. extend ( bm) ;
3212- }
3216+ let ( bm , np ) = self . compute_and_check_or_pat_binding_map ( ps) ;
3217+ binding_map. extend ( bm) ;
3218+ is_never_pat |= np ;
32133219 return false ;
32143220 }
3221+ PatKind :: Never => is_never_pat = true ,
32153222 _ => { }
32163223 }
32173224
32183225 true
32193226 } ) ;
32203227
3221- binding_map
3228+ if is_never_pat {
3229+ for ( _, binding) in binding_map {
3230+ self . report_error ( binding. span , ResolutionError :: BindingInNeverPattern ) ;
3231+ }
3232+ Err ( IsNeverPattern )
3233+ } else {
3234+ Ok ( binding_map)
3235+ }
32223236 }
32233237
32243238 fn is_base_res_local ( & self , nid : NodeId ) -> bool {
@@ -3228,33 +3242,37 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
32283242 )
32293243 }
32303244
3231- /// Checks that all of the arms in an or-pattern have exactly the
3232- /// same set of bindings, with the same binding modes for each.
3233- fn check_consistent_bindings (
3245+ /// Compute the binding map for an or-pattern. Checks that all of the arms in the or-pattern
3246+ /// have exactly the same set of bindings, with the same binding modes for each.
3247+ /// Returns the computed binding map and a boolean indicating whether the pattern is a never
3248+ /// pattern.
3249+ fn compute_and_check_or_pat_binding_map (
32343250 & mut self ,
32353251 pats : & [ P < Pat > ] ,
3236- ) -> Vec < FxIndexMap < Ident , BindingInfo > > {
3237- // pats is consistent.
3252+ ) -> ( FxIndexMap < Ident , BindingInfo > , bool ) {
32383253 let mut missing_vars = FxIndexMap :: default ( ) ;
32393254 let mut inconsistent_vars = FxIndexMap :: default ( ) ;
32403255
3241- // 1) Compute the binding maps of all arms.
3242- let maps = pats. iter ( ) . map ( |pat| self . binding_mode_map ( pat) ) . collect :: < Vec < _ > > ( ) ;
3256+ // 1) Compute the binding maps of all arms; never patterns don't participate in this.
3257+ let not_never_pats = pats
3258+ . iter ( )
3259+ . filter_map ( |pat| {
3260+ let binding_map = self . compute_and_check_binding_map ( pat) . ok ( ) ?;
3261+ Some ( ( binding_map, pat) )
3262+ } )
3263+ . collect :: < Vec < _ > > ( ) ;
32433264
32443265 // 2) Record any missing bindings or binding mode inconsistencies.
3245- for ( map_outer, pat_outer) in maps . iter ( ) . zip ( pats . iter ( ) ) {
3266+ for ( map_outer, pat_outer) in not_never_pats . iter ( ) {
32463267 // Check against all arms except for the same pattern which is always self-consistent.
3247- let inners = maps
3268+ let inners = not_never_pats
32483269 . iter ( )
3249- . zip ( pats. iter ( ) )
32503270 . filter ( |( _, pat) | pat. id != pat_outer. id )
3251- . flat_map ( |( map, _) | map)
3252- . map ( |( key, binding) | ( key. name , map_outer. get ( key) , binding) ) ;
3253-
3254- let inners = inners. collect :: < Vec < _ > > ( ) ;
3271+ . flat_map ( |( map, _) | map) ;
32553272
3256- for ( name, info, & binding_inner) in inners {
3257- match info {
3273+ for ( key, binding_inner) in inners {
3274+ let name = key. name ;
3275+ match map_outer. get ( key) {
32583276 None => {
32593277 // The inner binding is missing in the outer.
32603278 let binding_error =
@@ -3295,19 +3313,18 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
32953313 self . report_error ( v. 0 , ResolutionError :: VariableBoundWithDifferentMode ( name, v. 1 ) ) ;
32963314 }
32973315
3298- // 5) Finally bubble up all the binding maps.
3299- maps
3316+ // 5) Bubble up the final binding map.
3317+ let is_never_pat = not_never_pats. is_empty ( ) ;
3318+ let mut binding_map = FxIndexMap :: default ( ) ;
3319+ for ( bm, _) in not_never_pats {
3320+ binding_map. extend ( bm) ;
3321+ }
3322+ ( binding_map, is_never_pat)
33003323 }
33013324
3302- /// Check the consistency of the outermost or-patterns.
3303- fn check_consistent_bindings_top ( & mut self , pat : & ' ast Pat ) {
3304- pat. walk ( & mut |pat| match pat. kind {
3305- PatKind :: Or ( ref ps) => {
3306- self . check_consistent_bindings ( ps) ;
3307- false
3308- }
3309- _ => true ,
3310- } )
3325+ /// Check the consistency of bindings wrt or-patterns and never patterns.
3326+ fn check_consistent_bindings ( & mut self , pat : & ' ast Pat ) {
3327+ let _ = self . compute_and_check_binding_map ( pat) ;
33113328 }
33123329
33133330 fn resolve_arm ( & mut self , arm : & ' ast Arm ) {
@@ -3336,7 +3353,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
33363353 visit:: walk_pat ( self , pat) ;
33373354 self . resolve_pattern_inner ( pat, pat_src, bindings) ;
33383355 // This has to happen *after* we determine which pat_idents are variants:
3339- self . check_consistent_bindings_top ( pat) ;
3356+ self . check_consistent_bindings ( pat) ;
33403357 }
33413358
33423359 /// Resolve bindings in a pattern. This is a helper to `resolve_pattern`.
0 commit comments