error: cannot find macro `bang_proc_macrp!` in this scope
  --> $DIR/resolve-error.rs:56:5
   |
LL |     bang_proc_macrp!();
   |     ^^^^^^^^^^^^^^^ help: a macro with a similar name exists: `bang_proc_macro`

error: cannot find macro `Dlona!` in this scope
  --> $DIR/resolve-error.rs:53:5
   |
LL |     Dlona!();
   |     ^^^^^

error: cannot find macro `attr_proc_macra!` in this scope
  --> $DIR/resolve-error.rs:50:5
   |
LL |     attr_proc_macra!();
   |     ^^^^^^^^^^^^^^^ help: a macro with a similar name exists: `attr_proc_mac`

error: cannot find macro `FooWithLongNama!` in this scope
  --> $DIR/resolve-error.rs:47:5
   |
LL |     FooWithLongNama!();
   |     ^^^^^^^^^^^^^^^ help: a macro with a similar name exists: `FooWithLongNam`

error: cannot find derive macro `attr_proc_macra` in this scope
  --> $DIR/resolve-error.rs:42:10
   |
LL | #[derive(attr_proc_macra)]
   |          ^^^^^^^^^^^^^^^

error: cannot find derive macro `Dlona` in this scope
  --> $DIR/resolve-error.rs:38:10
   |
LL | #[derive(Dlona)]
   |          ^^^^^ help: a derive macro with a similar name exists: `Clona`

error: cannot find derive macro `Dlone` in this scope
  --> $DIR/resolve-error.rs:34:10
   |
LL | #[derive(Dlone)]
   |          ^^^^^ help: a derive macro with a similar name exists: `Clone`

error: cannot find attribute macro `FooWithLongNan` in this scope
  --> $DIR/resolve-error.rs:31:3
   |
LL | #[FooWithLongNan]
   |   ^^^^^^^^^^^^^^

error: cannot find attribute macro `attr_proc_macra` in this scope
  --> $DIR/resolve-error.rs:27:3
   |
LL | #[attr_proc_macra]
   |   ^^^^^^^^^^^^^^^ help: an attribute macro with a similar name exists: `attr_proc_macro`

error: cannot find derive macro `FooWithLongNan` in this scope
  --> $DIR/resolve-error.rs:22:10
   |
LL | #[derive(FooWithLongNan)]
   |          ^^^^^^^^^^^^^^ help: a derive macro with a similar name exists: `FooWithLongName`

error: aborting due to 10 previous errors

