Background/Situation

For applications that work with internal events, it may be necessary to navigate from the point where an event is sent to the method that handles it. However, this could be challenging due to the application's complexity, like when the queue manager and handlers work through a couple of interfaces and abstractions.

Some ways to navigate the events are through a Regex search of “<method>.*<EventName>” to find the method that actually handles the Event, or use the Structural search.

Question

Is there a way to make this easier? For example, could I save a search template and bind it to a hotkey?

Answer

For huge applications, applying the mentioned options may not be the best approach because of repetitive typing, regex limitations, performance issues, and missing IDE intelligence. Moreover, the selected option to navigate the events also depends on the nature and complexity of the application.

Below are listed the different approaches to navigating between internal Event sending and handling in IntelliJ IDEA, as well as the steps to implement them:

1. Create a Custom Search Template. You can save your search pattern as a template for quick reuse:

   1. Press ⇧ ⌘ A to open the "Find Action" dialog
   2. Type "structural" and select "Structural Search"
   3. Create your search pattern for Signal handlers
   4. Click the Settings icon and select "Save Template"
   5. Give it a name like "Signal Handler Search."

2. Use Search Everywhere with Symbol Search. A more powerful approach would be to use Symbol Search:

   1. Press ⌥ ⌘ Oto directly Search for Symbols (methods, fields, etc.)
   2. Type the Signal name you're looking for
   3. This will show all occurrences of the symbol, including both where it's sent and handled

3. Create a Custom Keyboard Shortcut for Your Search. You can bind your frequently used search to a custom shortcut:

   1. Open Settings (⌘ ,)
   2. Go to Keymap
   3. Find "Find in Files" action
   4. Right-click and add a keyboard shortcut
   5. In the Find in Files dialog, you can access your search history and previous patterns

4. Use Navigation Actions. When you're at the Signal sending point, you can use these navigation features:

   • Navigate to the implementation(s) of the selected class or method. (Usually `⌥` `⌘` `B`) - This will show all implementations of the interface method
   • Find usages of the symbol at the caret. (Usually `⌥` `F7`) - This will show all usages of the Signal, including where it's handled

These approaches are more efficient than using regex search every time, and they take advantage of IntelliJ's code understanding capabilities. The Symbol Search (⌥ ⌘ O) is particularly recommended as it understands your code structure and can find related symbols regardless of the naming pattern.

Additionally, once you find a handler, you can use Bookmarks:

• Use Quick Bookmarking. To bookmark important handlers for quick access
• Use Toggle Bookmarks. With mnemonics to create numbered bookmarks for frequently accessed handlers

Pro Tips:

• For frequently accessed handlers, use mnemonic bookmarks with memorable letters (e.g., 'E' for important Event handlers)
• You can create a dedicated list called "Event Handlers" to keep them organized
• If you have multiple related handlers, you can bookmark them all and group them in a custom list

Which of the above suggestions is the most efficient?

For complex applications the Symbol Search (using ⌥ ⌘ O) in many cases would be the most efficient solution for several reasons:

1. Speed and Immediacy:
   • It's a direct shortcut (⌥ ⌘ O)
   • No need to set up templates or custom configurations
   • Much faster due to IntelliJ's indexing
   • Results appear instantly as you type
2. Intelligence:
   • Unlike regex search, it understands your code structure
   • It's aware of the context and relationships between symbols
   • It can find symbols across your entire project, regardless of the file structure
   • Shows results organized by type (methods, classes, etc.)
3. Accuracy:
   • More precise than regex searching for "<method>* "
   • Reduces false positives since it looks for actual symbols rather than text patterns
   • Shows both declarations and usages in a structured way
4. Workflow:
   1. Press ⌥ ⌘ O
   2. Type your Signal name
   3. Get immediate results showing both where the Signal is defined and handled
   4. Navigate directly to any occurrence

Thus, this built-in navigation feature is more efficient than the other suggestions because:

• Structural search templates require initial setup time
• Custom keyboard shortcuts still need you to configure the search pattern
• Regular Find Usages might give too broad results

However, Find Usages (⌥ F7) could be a good alternative to use, depending on your needs due to:

1. Can be used when the caret is placed on an Event type or method:
   • The Event class name (UserLoggedInEvent)
   • The Event usage (new UserLoggedInEvent)
   • A method that uses the Event
2. Shows all places where the Event is used
   • Where this Signal is created
   • Where it's handled
   • Where it's passed as a parameter
   • Any other references to this Signal type
3. Organizes results by usage type (read/write/call)
4. Understands inheritance and implementation relationships
5. Easy to use
   1. You don't need to type anything. The key difference from Regex search, because it starts from a reference point in the code (where the cursor is) rather than typing a search pattern.
   2. Just position the cursor and press the shortcut
   3. Get all related code locations immediately

To conclude, these two built-in navigation features are more reliable and maintainable than regex patterns because they:

• Understand your code structure
• Are resistant to refactoring
• Provide more accurate results
• Are faster to use
• Don't require remembering or typing search patterns