Compiling Groovy code is typically slower than compiling Java code, but in 14.1 we took a swing at speeding it up. First, we're now supporting Groovy-Eclipse compiler that handles Java and Groovy simultaneously, which brings a noticeable performance gain. So, if you're compiling your projects in Eclipse, you might want to give this new integration a try. Just go to the Java Compiler settings, select Groovy-Eclipse, and point to the groovy-eclipse-batch.jar. Remember that is should be the same version as your Groovy distribution. (more…)

Java annotations are awesome and helpful, but you need to add them by hand. Well, not anymore, because IntelliJ IDEA will do that for you in some quite important cases. Jars in your dependencies are stuffed with methods and sometimes it may be difficult to tell whether you can pass null there without blowing things up, or whether you should be ready to get null as a method result. If you're lucky, the documentation will specify that, if not, you have to read the source code, or even the decompiled output, which is not always as easy as you'd like it to be. There are, of course, NotNull/N

Did you know how to quickly complete a static method call or a constant reference without writing the class name first? Just type some prefix and invoke Basic Code Completion (Ctrl+Space) twice (or Ctrl+Alt+Space once): There are two problems though: The entire project is searched and there might be just plain too many completely unrelated suggestions, and it's hard to search among them what you need. You may not remember the name of the member you want while knowing what it type should be. Now we have a solution for these problems. It's the plain old second SmartType Completion (Ctrl+Sh

As you know code completion in IntelliJ IDEA constantly evolves. Here's a few new features coming in IntelliJ IDEA 12: Middle matching Class Name Completion in Basic Completion Completion statistics in Productivity Guide Other minor improvements (more…)

Here I would like to tell you about some of the Groovy language support improvements available in IntelliJ IDEA 11.1. Unused Symbol Highlighting If a class, method or property is unused even if it is in fact public, you may notice it immediately with new unused symbol highlighting feature. (more…)

Sometimes you invoke an action and you don't get what you wanted immediately. In such cases it may help to invoke the action again by pressing the same shortcut. In basic code completion (Ctrl+Space) this will list non-imported classes: It works in similar way for smart-type and class name completions: In File Structure popup (Ctrl+F12) you will show inherited members with it: When introducing a variable (Ctrl+Alt+V), you may want to reassign an existing one instead: I may have missed something, but all this is already available in IntelliJ IDEA 11. And there's a couple more nice t

If you use completion autopopup in IntelliJ IDEA 11, you may have seen "n variants..." suggestions: This means there are two StringUtil classes available, neither of them is imported, and IDE can't choose which of them to put to the first place. When you choose such variant no new import statements will be added. The good side is that you won't get wrong imports after pressing space, dot or a bracket. The bad side is that you eventually have to face this choice: you may either explicitly invoke completion (Ctrl+Space) again or choose the correct qualified name from the auto-import hint whic

With IntelliJ IDEA 10.5, you may press up to twice as less keys every day as you do now. Seriously! Here's how. The reason IDEs exist in the first place is that they make your life easier. In particular, they are able to generate code for you. An ideal IDE would do all the boring typing by itself, leaving you more time for thinking about the great software engineering problems you face. Unfortunately, such an ideal is not there yet. Currently, if you want an IDE to help you, you first have to help it help you. Usually this means giving it some cues on a word you have in mind, and it then trie

IntelliJ IDEA is a great IDE for Java, Groovy, Flex, Python, Ruby and many other languages. The text editor with camel-hump completion, and version control support are so great that it may be hard to switch to another editor which may lack some useful features. So, when a need arises for me to code in a language that's not listed on the features page, I just teach IDEA some basics about that language, and feel much more comfortable than I would if I was editing a plain text. Luckily, you don't have to write a plugin for that, it is possible via the GUI. Assume you want to edit Haskell code in

Groovy's as keyword allows for some interesting features. In particular, it provides a convenient syntactic sugar for object creation: KeyAdapter listener = [         keyTyped: { e -> … },         keyReleased: { e -> … } ] as KeyAdapter Still in development, but already quite usable, there is Groovy++: a library which adds static typing, performance and much more to Groovy language. One thing you get addicted to quite soon is that you don't have to write as in the cases above anymore. If the compiler can

Once I wrote about console folding for Groovy stacktraces. Naturally, many people wished similar things could work for other languages and frameworks. Long story short, there's now a settings page dedicated to the console folding. It provides a settings page where you may specify which console lines to fold: This functionality is available in IDEA 9.0.2 via Console Folding plugin. In IDEA X, it will be bundled. Furthermore, there will be a nice addition to these settings: an action that allows you to add folding rules very easily right from the console. Just select the fragment which will tog

When you look at a typical Groovy stack trace, you usually see something like this: This is not terribly helpful, since there are only three lines from the actual source code. Everything else refers to Groovy's internals. From now on, though, reading Groovy stack traces will be much easier: