From a42f8160edd63a2cd2dad5a1b1d42c2ec67c60ae Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Mon, 12 Jun 2017 21:10:53 +0200 Subject: [PATCH] Add E0612 --- src/librustc_typeck/check/mod.rs | 36 ++++++++----------- src/librustc_typeck/diagnostics.rs | 34 ++++++++++++++++++ src/test/compile-fail/E0612.rs | 16 +++++++++ src/test/compile-fail/struct-field-privacy.rs | 2 +- .../macro-backtrace-invalid-internals.stderr | 4 +-- 5 files changed, 68 insertions(+), 24 deletions(-) create mode 100644 src/test/compile-fail/E0612.rs diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 61d140a245a..fff6cb068c8 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -3053,26 +3053,20 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { let struct_path = self.tcx().item_path_str(did); struct_span_err!(self.tcx().sess, expr.span, E0611, "field `{}` of tuple-struct `{}` is private", - idx.node, struct_path); + idx.node, struct_path).emit(); return field_ty; } - self.type_error_message( - expr.span, - |actual| { - if tuple_like { - format!("attempted out-of-bounds tuple index `{}` on \ - type `{}`", - idx.node, - actual) - } else { - format!("attempted tuple index `{}` on type `{}`, but the \ - type was not a tuple or tuple struct", - idx.node, - actual) - } - }, - expr_t); + if tuple_like { + type_error_struct!(self.tcx().sess, expr.span, expr_t, E0612, + "attempted out-of-bounds tuple index `{}` on type `{}`", + idx.node, expr_t).emit(); + } else { + type_error_struct!(self.tcx().sess, expr.span, expr_t, E0613, + "attempted tuple index `{}` on type `{}`, but the type was not a \ + tuple or tuple struct", + idx.node, expr_t).emit(); + } self.tcx().types.err } @@ -3173,10 +3167,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { field_type_hint = tcx.types.err; if let Some(_) = variant.find_field_named(field.name.node) { let mut err = struct_span_err!(self.tcx.sess, - field.name.span, - E0062, - "field `{}` specified more than once", - field.name.node); + field.name.span, + E0062, + "field `{}` specified more than once", + field.name.node); err.span_label(field.name.span, "used more than once"); diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs index 223206fffc5..9eff22027c7 100644 --- a/src/librustc_typeck/diagnostics.rs +++ b/src/librustc_typeck/diagnostics.rs @@ -4208,6 +4208,40 @@ println!("{}", y.get()); // So we can get the value through the function. ``` "##, +E0612: r##" +Attempted out-of-bounds tuple index. + +Erroneous code example: + +```compile_fail,E0612 +struct Foo(u32); + +let y = Foo(0); +println!("{}", y.1); // error: attempted out-of-bounds tuple index `1` + // on type `Foo` +``` + +If a tuple/tuple-struct type has n fields, you can only try to access these n +fields from 0 to (n - 1). So in this case, you can only index `0`. Example: + +``` +struct Foo(u32); + +let y = Foo(0); +println!("{}", y.0); // ok! +``` +"##, + +E0613: r##" +Attempted tuple index on a type which isn't a tuple nor a tuple-struct. + +Erroneous code example: + +```compile_fail,E0613 + +``` +"##, + E0617: r##" Attempted to pass an invalid type of variable into a variadic function. diff --git a/src/test/compile-fail/E0612.rs b/src/test/compile-fail/E0612.rs new file mode 100644 index 00000000000..429a8bb7eb7 --- /dev/null +++ b/src/test/compile-fail/E0612.rs @@ -0,0 +1,16 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +struct Foo(u32); + +fn main() { + let y = Foo(0); + y.1; //~ ERROR E0612 +} diff --git a/src/test/compile-fail/struct-field-privacy.rs b/src/test/compile-fail/struct-field-privacy.rs index f487ef62aa4..5b2e04e25a9 100644 --- a/src/test/compile-fail/struct-field-privacy.rs +++ b/src/test/compile-fail/struct-field-privacy.rs @@ -42,7 +42,7 @@ fn test(a: A, b: inner::A, c: inner::B, d: xc::A, e: xc::B, z: inner::Z) { e.b; //~ ERROR: field `b` of struct `xc::B` is private z.0; - z.1; //~ ERROR: field `1` of struct `inner::Z` is private + z.1; //~ ERROR: field `1` of tuple-struct `inner::Z` is private } fn main() {} diff --git a/src/test/ui/macros/macro-backtrace-invalid-internals.stderr b/src/test/ui/macros/macro-backtrace-invalid-internals.stderr index 95db694a0c6..136b04fcb0f 100644 --- a/src/test/ui/macros/macro-backtrace-invalid-internals.stderr +++ b/src/test/ui/macros/macro-backtrace-invalid-internals.stderr @@ -16,7 +16,7 @@ error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields 51 | fake_field_stmt!(); | ------------------- in this macro invocation -error: attempted tuple index `0` on type `{integer}`, but the type was not a tuple or tuple struct +error[E0613]: attempted tuple index `0` on type `{integer}`, but the type was not a tuple or tuple struct --> $DIR/macro-backtrace-invalid-internals.rs:27:11 | 27 | (1).0 @@ -43,7 +43,7 @@ error[E0610]: `{integer}` is a primitive type and therefore doesn't have fields 55 | let _ = fake_field_expr!(); | ------------------ in this macro invocation -error: attempted tuple index `0` on type `{integer}`, but the type was not a tuple or tuple struct +error[E0613]: attempted tuple index `0` on type `{integer}`, but the type was not a tuple or tuple struct --> $DIR/macro-backtrace-invalid-internals.rs:45:11 | 45 | (1).0