Completions for macros in #[macro_use(...)] of extern crate/mod declaration

[Veykril]

#[macro_use($0)]
extern crate foo;

we should be completing the exported macros of the foo crate here.
Likewise for modules

#[macro_use($0)]
mod foo;
#[macro_use($0)]
mod bar { ... }

[Veykril]

We'll have to add a new arm to the match here

rust-analyzer/crates/ide-completion/src/completions/attribute.rs

Lines 49 to 70 in 8a23314

	match path.text().as_str() {
	"repr" => repr::complete_repr(acc, ctx, tt),
	"feature" => {
	lint::complete_lint(acc, ctx, colon_prefix, &parse_tt_as_comma_sep_paths(tt)?, FEATURES)
	}
	"allow" | "warn" | "deny" | "forbid" => {
	let existing_lints = parse_tt_as_comma_sep_paths(tt)?;
	let lints: Vec<Lint> = CLIPPY_LINT_GROUPS
	.iter()
	.map(|g| &g.lint)
	.chain(DEFAULT_LINTS)
	.chain(CLIPPY_LINTS)
	.chain(RUSTDOC_LINTS)
	.cloned()
	.collect();
	lint::complete_lint(acc, ctx, colon_prefix, &existing_lints, &lints);
	}
	"cfg" => cfg::complete_cfg(acc, ctx),
	_ => (),
	}

and create a corresponding submodule in crates/ide-completion/src/completions/attribute/macro_use.rs.

Then we'll need to figure out what the attribute we are completing in is actually attached to. For that we need to add a new field here

rust-analyzer/crates/ide-completion/src/context.rs

Lines 370 to 374 in 8a23314

	/// Set if we are currently completing in an unexpanded attribute, this usually implies a builtin attribute like `allow($0)`
	UnexpandedAttrTT {
	colon_prefix: bool,
	fake_attribute_under_caret: Option<ast::Attr>,
	},

of type ModuleDef and populate it here appropriately

rust-analyzer/crates/ide-completion/src/context/analysis.rs

Lines 257 to 262 in 8a23314

	CompletionAnalysis::UnexpandedAttrTT {
	fake_attribute_under_caret: fake_ident_token
	.parent_ancestors()
	.find_map(ast::Attr::cast),
	colon_prefix,
	}

Then in the newly created completions module we'll have to check if the definition the attribute is attached to is a module or extern crate and fetch the exported macros for that from there.

[unexge]

Seems like arguments to #[macro_use] are not allowed for modules. This fails:

#[macro_use(foo)] // <- error: arguments to `macro_use` are not allowed here
mod inner {
    macro_rules! foo {
        () => {};
    }
}

fn main() {}

We should just autocomplete if #[macro_use] is applied to extern crate