diff --git a/src/librustc_privacy/diagnostics.rs b/src/librustc_privacy/diagnostics.rs new file mode 100644 index 0000000000000..0f9f00e1b49a9 --- /dev/null +++ b/src/librustc_privacy/diagnostics.rs @@ -0,0 +1,235 @@ +// Copyright 2014 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. + +#![allow(non_snake_case)] + +register_long_diagnostics! { + +E0445: r##" +A private trait was used on a public type parameter bound. Erroneous code +examples: + +``` +trait Foo { + fn dummy(&self) { } +} + +pub trait Bar : Foo {} // error: private trait in exported type parameter bound +pub struct Bar(pub T); // same error +pub fn foo (t: T) {} // same error +``` + +To solve this error, please ensure that the trait is also public and accessible +at the same level of the public functions or types which are bound on it. +Example: + +``` +pub trait Foo { // we set the Foo trait public + fn dummy(&self) { } +} + +pub trait Bar : Foo {} // ok! +pub struct Bar(pub T); // ok! +pub fn foo (t: T) {} // ok! +``` +"##, + +E0446: r##" +A private type was used in an exported type signature. Erroneous code example: + +``` +mod Foo { + struct Bar(u32); + + pub fn bar() -> Bar { // error: private type in exported type signature + Bar(0) + } +} +``` + +To solve this error, please ensure that the type is also public and accessible +at the same level of the public functions or types which use it. Example: + +``` +mod Foo { + pub struct Bar(u32); // we set the Bar type public + + pub fn bar() -> Bar { // ok! + Bar(0) + } +} +``` +"##, + +E0447: r##" +The `pub` keyword was used inside a function. Erroneous code example: + +``` +fn foo() { + pub struct Bar; // error: visibility has no effect inside functions +} +``` + +Since we cannot access items defined inside a function, the visibility of its +items does not impact outer code. So using the `pub` keyword in this context +is invalid. +"##, + +E0448: r##" +The `pub` keyword was used inside a public enum. Erroneous code example: + +``` +pub enum Foo { + pub Bar, // error: unnecessary `pub` visibility +} +``` + +Since the enum is already public, adding `pub` on one its elements is +unnecessary. Example: + +``` +enum Foo { + pub Bar, // ok! +} + +// or: + +pub enum Foo { + Bar, // ok! +} +``` +"##, + +E0449: r##" +A visibility qualifier was used when it was unnecessary. Erroneous code +examples: + +``` +struct Bar; + +trait Foo { + fn foo(); +} + +pub impl Bar {} // error: unnecessary visibility qualifier + +pub impl Foo for Bar { // error: unnecessary visibility qualifier + pub fn foo() {} // error: unnecessary visibility qualifier +} +``` + +To fix this error, please remove the visibility qualifier when it is not +required. Example: + +``` +struct Bar; + +trait Foo { + fn foo(); +} + +// Directly implemented methods share the visibility of the type itself, +// so `pub` is unnecessary here +impl Bar {} + +// Trait methods share the visibility of the trait, so `pub` is +// unnecessary in either case +pub impl Foo for Bar { + pub fn foo() {} +} +``` +"##, + +E0450: r##" +A tuple constructor was invoked while some of its fields are private. Erroneous +code example: + +``` +mod Bar { + pub struct Foo(isize); +} + +let f = Bar::Foo(0); // error: cannot invoke tuple struct constructor with + // private fields +``` + +To solve this issue, please ensure that all of the fields of the tuple struct +are public. Alternatively, provide a new() method to the tuple struct to +construct it from a given inner value. Example: + +``` +mod Bar { + pub struct Foo(pub isize); // we set its field to public +} + +let f = Bar::Foo(0); // ok! + +// or: +mod bar { + pub struct Foo(isize); + + impl Foo { + pub fn new(x: isize) { + Foo(x) + } + } +} + +let f = bar::Foo::new(1); +``` +"##, + +E0451: r##" +A struct constructor with private fields was invoked. Erroneous code example: + +``` +mod Bar { + pub struct Foo { + pub a: isize, + b: isize, + } +} + +let f = Bar::Foo{ a: 0, b: 0 }; // error: field `b` of struct `Bar::Foo` + // is private +``` + +To fix this error, please ensure that all the fields of the struct, or +implement a function for easy instantiation. Examples: + +``` +mod Bar { + pub struct Foo { + pub a: isize, + pub b: isize, // we set `b` field public + } +} + +let f = Bar::Foo{ a: 0, b: 0 }; // ok! + +// or: +mod Bar { + pub struct Foo { + pub a: isize, + b: isize, // still private + } + + impl Foo { + pub fn new() -> Foo { // we create a method to instantiate `Foo` + Foo { a: 0, b: 0 } + } + } +} + +let f = Bar::Foo::new(); // ok! +``` +"##, + +} diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 7f72ccb51e60d..48efd34e21220 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -50,6 +50,8 @@ use rustc::front::map as ast_map; use syntax::ast; use syntax::codemap::Span; +pub mod diagnostics; + type Context<'a, 'tcx> = (&'a ty::MethodMap<'tcx>, &'a def::ExportMap); /// Result of a checking operation - None => no errors were found. Some => an @@ -715,7 +717,8 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> { UnnamedField(idx) => format!("field #{} of {} is private", idx + 1, struct_desc), }; - self.tcx.sess.span_err(span, &msg[..]); + span_err!(self.tcx.sess, span, E0451, + "{}", &msg[..]); } // Given the ID of a method, checks to ensure it's in scope. @@ -929,9 +932,9 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { }); if any_priv { - self.tcx.sess.span_err(expr.span, - "cannot invoke tuple struct constructor \ - with private fields"); + span_err!(self.tcx.sess, expr.span, E0450, + "cannot invoke tuple struct constructor with private \ + fields"); } } } @@ -1043,7 +1046,8 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { let tcx = self.tcx; let check_inherited = |sp: Span, vis: hir::Visibility, note: &str| { if vis != hir::Inherited { - tcx.sess.span_err(sp, "unnecessary visibility qualifier"); + span_err!(tcx.sess, sp, E0449, + "unnecessary visibility qualifier"); if !note.is_empty() { tcx.sess.span_note(sp, note); } @@ -1076,8 +1080,8 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { match v.node.vis { hir::Public => { if item.vis == hir::Public { - tcx.sess.span_err(v.span, "unnecessary `pub` \ - visibility"); + span_err!(tcx.sess, v.span, E0448, + "unnecessary `pub` visibility"); } } hir::Inherited => {} @@ -1098,7 +1102,8 @@ impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> { let tcx = self.tcx; fn check_inherited(tcx: &ty::ctxt, sp: Span, vis: hir::Visibility) { if vis != hir::Inherited { - tcx.sess.span_err(sp, "visibility has no effect inside functions"); + span_err!(tcx.sess, sp, E0447, + "visibility has no effect inside functions"); } } let check_struct = |def: &hir::StructDef| { @@ -1193,8 +1198,8 @@ impl<'a, 'tcx> VisiblePrivateTypesVisitor<'a, 'tcx> { if !self.tcx.sess.features.borrow().visible_private_types && self.path_is_private_type(trait_ref.trait_ref.ref_id) { let span = trait_ref.trait_ref.path.span; - self.tcx.sess.span_err(span, "private trait in exported type \ - parameter bound"); + span_err!(self.tcx.sess, span, E0445, + "private trait in exported type parameter bound"); } } } @@ -1435,7 +1440,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> { if let hir::TyPath(_, ref p) = t.node { if !self.tcx.sess.features.borrow().visible_private_types && self.path_is_private_type(t.id) { - self.tcx.sess.span_err(p.span, "private type in exported type signature"); + span_err!(self.tcx.sess, p.span, E0446, + "private type in exported type signature"); } } visit::walk_ty(self, t)