From 84843b73dc8e54f1e8c1e4418b7d56dbd513dd65 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 6 May 2016 20:42:23 +0530 Subject: [PATCH] Merge E0410 into E0408 --- src/librustc_resolve/diagnostics.rs | 29 ++++++++++++++--------------- src/librustc_resolve/lib.rs | 25 ++++++++----------------- 2 files changed, 22 insertions(+), 32 deletions(-) diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index 161dcf79dcc..35148622052 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/src/librustc_resolve/diagnostics.rs @@ -506,12 +506,11 @@ Example of erroneous code: ```compile_fail match x { Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is - // not bound in pattern #2 + // not bound in pattern #2 _ => () } ``` - Here, `y` is bound to the contents of the `Some` and can be used within the block corresponding to the match arm. However, in case `x` is `None`, we have not specified what `y` is, and the block will use a nonexistent variable. @@ -530,14 +529,15 @@ or, bind the variable to a field of the same type in all sub-patterns of the or pattern: ``` -let x = (0,2); +let x = (0, 2); match x { (0, y) | (y, 0) => { /* use y */} + _ => {} } ``` In this example, if `x` matches the pattern `(0, _)`, the second field is set -to `y`, and if it matches `(_, 0)`, the first field is set to `y`, so in all +to `y`. If it matches `(_, 0)`, the first field is set to `y`; so in all cases `y` is set to some value. "##, @@ -548,36 +548,35 @@ across patterns. Example of erroneous code: ```compile_fail -let x = (0,2); +let x = (0, 2); match x { (0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with - // different mode in pattern #2 than - // in pattern #1 + // different mode in pattern #2 + // than in pattern #1 _ => () } ``` - Here, `y` is bound by-value in one case and by-reference in the other. To fix this error, just use the same mode in both cases. -Generally using `ref` or `ref mut` where not already used will fix this. +Generally using `ref` or `ref mut` where not already used will fix this: -``` -let x = (0,2); +```ignore +let x = (0, 2); match x { (0, ref y) | (ref y, 0) => { /* use y */} _ => () } ``` -Alternatively, split the pattern +Alternatively, split the pattern: -```compile_fail -let x = (0,2); +``` +let x = (0, 2); match x { - (0, ref y) => { /* use y */} (y, 0) => { /* use y */ } + (0, ref y) => { /* use y */} _ => () } ``` diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 7c6c76f130e..e3c2a9300ba 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -126,12 +126,10 @@ enum ResolutionError<'a> { TypeNotMemberOfTrait(Name, &'a str), /// error E0438: const is not a member of trait ConstNotMemberOfTrait(Name, &'a str), - /// error E0408: variable `{}` from pattern #1 is not bound in pattern - VariableNotBoundInPattern(Name, usize), + /// error E0408: variable `{}` from pattern #{} is not bound in pattern #{} + VariableNotBoundInPattern(Name, usize, usize), /// error E0409: variable is bound with different mode in pattern #{} than in pattern #1 VariableBoundWithDifferentMode(Name, usize), - /// error E0410: variable from pattern is not bound in pattern #1 - VariableNotBoundInParentPattern(Name, usize), /// error E0411: use of `Self` outside of an impl or trait SelfUsedOutsideImplOrTrait, /// error E0412: use of undeclared @@ -272,13 +270,14 @@ fn resolve_struct_error<'b, 'a: 'b, 'tcx: 'a>(resolver: &'b Resolver<'a, 'tcx>, const_, trait_) } - ResolutionError::VariableNotBoundInPattern(variable_name, pattern_number) => { + ResolutionError::VariableNotBoundInPattern(variable_name, from, to) => { struct_span_err!(resolver.session, span, E0408, - "variable `{}` from pattern #1 is not bound in pattern #{}", + "variable `{}` from pattern #{} is not bound in pattern #{}", variable_name, - pattern_number) + from, + to) } ResolutionError::VariableBoundWithDifferentMode(variable_name, pattern_number) => { struct_span_err!(resolver.session, @@ -289,14 +288,6 @@ fn resolve_struct_error<'b, 'a: 'b, 'tcx: 'a>(resolver: &'b Resolver<'a, 'tcx>, variable_name, pattern_number) } - ResolutionError::VariableNotBoundInParentPattern(variable_name, pattern_number) => { - struct_span_err!(resolver.session, - span, - E0410, - "variable `{}` from pattern #{} is not bound in pattern #1", - variable_name, - pattern_number) - } ResolutionError::SelfUsedOutsideImplOrTrait => { struct_span_err!(resolver.session, span, @@ -2038,7 +2029,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { None => { resolve_error(self, p.span, - ResolutionError::VariableNotBoundInPattern(key, i + 1)); + ResolutionError::VariableNotBoundInPattern(key, 1, i + 1)); } Some(binding_i) => { if binding_0.binding_mode != binding_i.binding_mode { @@ -2055,7 +2046,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { if !map_0.contains_key(&key) { resolve_error(self, binding.span, - ResolutionError::VariableNotBoundInParentPattern(key, i + 1)); + ResolutionError::VariableNotBoundInPattern(key, i + 1, 1)); } } }