browsing graph of traits/structs/impls?

[dobkeratops]

Would there be any place in this IDE that could easily browse the graph of structs/traits/impls, -perhaps an enhancement of the structure window, (EDIT apparently this could go in the class hierarchy browser?)

Ideally this should be able to navigate globally, not just 'from the current file', showing the open graph-like relationship between the entities (contrasting with the inheritance hierarchy of traditional OOP)

When focussed on a trait: show all types that impl it,
When focussed on a type, show all traits that it impls's

It might also be handy to list all project wide functions that use a type, although this would get out of hand for universal types like 'Option', so there would be a need to sort by relevance (distance in module graph?) and apply a cutoff (perhaps collapsing excessive cases to 'related modules' would help)

The standard view of a 'file' would be a focus on a module

Whilst the overall IDE may be patterned around class based OOP, perhaps there is some correspondence elsewhere e.g. 'interfaces' (java classes can implement any number of interfaces in addition to inheriting?)

[matklad]

Yeah, something like this would be super useful!

We already have a way to list all the impls of a trait:

This is handled by org.rust.ide.annotator.RsTraitLineMarkerProvider.

The next step is to add a similar marker to find all impls of a struct.

It might also be handy to list all project wide functions that use a type

To implement this, we should add filtering by usage type to our "Find usages".

[matklad]

As for the general graph thing, this is handled by "Class hierarchy" infrastructure, but I think that gutter icons and filters in find usages are more high yield things to add right now.

[dobkeratops]

thanks, thats quite useful already;

I suppose another 'stopgap' might be to open things in the generated 'rustdoc' pages (which already has this 'graph' built, but it wont have as much context information at hand )

When writing rust in emacs I have a key setup which basically does a recursive grep for (struct|trait|impl|fn|enum|type) <thing at point> .. is there a way to setup a 'grep command' like that here, spitting out the results in the output pane

[matklad]

When writing rust in emacs I have a key setup which basically does a recursive grep for (struct|trait|impl|fn|enum|type) .

Hm, this sounds like Go to definition, which is Ctrl+B by default.

[dobkeratops]

sure I use the 'goto definition', it's very useful; sometimes the 'grep' also yields useful information , e.g. a function having multiple implementations, or indeed finding the references to types in the 'impl..for' lines . Obviously it can't filter or use context as well as an IDE. It can't find enum variants or fields. anyway thats just a tangent. ( I should look around more generally for this .. dedicated rust-aware solutions are far better)

(defun make-rust-grep-str	(curr-symbol dir exdir)	
  (concat
	"grep -rn -s \"\\(const\\|fn\\|struct\\|trait\\|for\\|impl\\|impl<.*>for\\|enum\\|static\\|static\\s*mut\\|type\\|mod\\|macro_rules!\\)\\s*"
				(partial-match-of curr-symbol)
				"\\b\" "
				dir
				" --include \"*.rs\""
	(if (>(length exdir)0) (concat " --exclude-dir " exdir " "))
                ))

[matklad]

Thanks for the clarification! I think you actually want Find Usages (Alt+F7) with filtering by type of the usage, which unfortunately is not implemented yet :(

[dobkeratops]

ok thats pretty good, and does of course find 'impls' (usages of a trait or type..) so it also does quite a bit of the original request. Seems thats better than the ad-hoc grep solution already.

[farodin91]

I will extend Find Usages.

[Kobzol]

This can be implemented via this API, if anyone is interested. Although I'm not sure if it's worth it for Rust.

It doesn't have struct inheritance, so type hierarchy can pretty much only consists of traits. Method overrides are also only one level deep. Maybe function call hierarchy can be useful, but I have personally never used it.