src/librustc_resolve/diagnostics.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![allow(non_snake_case)]
  12
  13 // Error messages for EXXXX errors.
  14 // Each message should start and end with a new line, and be wrapped to 80 characters.
  15 // In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use `:set tw=0` to disable.
  16 register_long_diagnostics! {
  17
  18 E0154: r##"
  19 Imports (`use` statements) are not allowed after non-item statements, such as
  20 variable declarations and expression statements.
  21
  22 Here is an example that demonstrates the error:
  23
  24 ```
  25 fn f() {
  26     // Variable declaration before import
  27     let x = 0;
  28     use std::io::Read;
  29     ...
  30 }
  31 ```
  32
  33 The solution is to declare the imports at the top of the block, function, or
  34 file.
  35
  36 Here is the previous example again, with the correct order:
  37
  38 ```
  39 fn f() {
  40     use std::io::Read;
  41     let x = 0;
  42     ...
  43 }
  44 ```
  45
  46 See the Declaration Statements section of the reference for more information
  47 about what constitutes an Item declaration and what does not:
  48
  49 http://doc.rust-lang.org/reference.html#statements
  50 "##,
  51
  52 E0251: r##"
  53 Two items of the same name cannot be imported without rebinding one of the
  54 items under a new local name.
  55
  56 An example of this error:
  57
  58 ```
  59 use foo::baz;
  60 use bar::*; // error, do `use foo::baz as quux` instead on the previous line
  61
  62 fn main() {}
  63
  64 mod foo {
  65     pub struct baz;
  66 }
  67
  68 mod bar {
  69     pub mod baz {}
  70 }
  71 ```
  72 "##,
  73
  74 E0252: r##"
  75 Two items of the same name cannot be imported without rebinding one of the
  76 items under a new local name.
  77
  78 An example of this error:
  79
  80 ```
  81 use foo::baz;
  82 use bar::baz; // error, do `use bar::baz as quux` instead
  83
  84 fn main() {}
  85
  86 mod foo {
  87     pub struct baz;
  88 }
  89
  90 mod bar {
  91     pub mod baz {}
  92 }
  93 ```
  94 "##,
  95
  96 E0255: r##"
  97 You can't import a value whose name is the same as another value defined in the
  98 module.
  99
 100 An example of this error:
 101
 102 ```
 103 use bar::foo; // error, do `use bar::foo as baz` instead
 104
 105 fn foo() {}
 106
 107 mod bar {
 108      pub fn foo() {}
 109 }
 110
 111 fn main() {}
 112 ```
 113 "##,
 114
 115 E0256: r##"
 116 You can't import a type or module when the name of the item being imported is
 117 the same as another type or submodule defined in the module.
 118
 119 An example of this error:
 120
 121 ```
 122 use foo::Bar; // error
 123
 124 type Bar = u32;
 125
 126 mod foo {
 127     pub mod Bar { }
 128 }
 129
 130 fn main() {}
 131 ```
 132 "##,
 133
 134 E0259: r##"
 135 The name chosen for an external crate conflicts with another external crate that
 136 has been imported into the current module.
 137
 138 Wrong example:
 139
 140 ```
 141 extern crate a;
 142 extern crate crate_a as a;
 143 ```
 144
 145 The solution is to choose a different name that doesn't conflict with any
 146 external crate imported into the current module.
 147
 148 Correct example:
 149
 150 ```
 151 extern crate a;
 152 extern crate crate_a as other_name;
 153 ```
 154 "##,
 155
 156 E0260: r##"
 157 The name for an item declaration conflicts with an external crate's name.
 158
 159 For instance,
 160
 161 ```
 162 extern crate abc;
 163
 164 struct abc;
 165 ```
 166
 167 There are two possible solutions:
 168
 169 Solution #1: Rename the item.
 170
 171 ```
 172 extern crate abc;
 173
 174 struct xyz;
 175 ```
 176
 177 Solution #2: Import the crate with a different name.
 178
 179 ```
 180 extern crate abc as xyz;
 181
 182 struct abc;
 183 ```
 184
 185 See the Declaration Statements section of the reference for more information
 186 about what constitutes an Item declaration and what does not:
 187
 188 http://doc.rust-lang.org/reference.html#statements
 189 "##,
 190
 191 E0317: r##"
 192 User-defined types or type parameters cannot shadow the primitive types.
 193 This error indicates you tried to define a type, struct or enum with the same
 194 name as an existing primitive type.
 195
 196 See the Types section of the reference for more information about the primitive
 197 types:
 198
 199 http://doc.rust-lang.org/reference.html#types
 200 "##
 201
 202 }
 203
 204 register_diagnostics! {
 205     E0157,
 206     E0153,
 207     E0253, // not directly importable
 208     E0254, // import conflicts with imported crate in this module
 209     E0257,
 210     E0258,
 211     E0364, // item is private
 212     E0365  // item is private
 213 }