Many of the features we're going to talk about in this post have been mentioned elsewhere in this blog, but here we're going to bring them all together and show how to use them. Better Warnings You'll have seen before that IntelliJ IDEA can analyse your code and tell you if something isn't needed, or perhaps doesn't make sense.  IntelliJ IDEA 2017.2 has even better analysis in several areas.  The first we're going to look at is Control Flow Analysis - IntelliJ IDEA can look at the logic in your code and tell you if certain cases just won't occur. For example, if a Collection or String

Earlier we mentioned that IntelliJ IDEA 2017.2 EAP features improved control flow analysis that infers the contracts of certain methods of String, Array, Collection and Map classes. With today’s EAP build, this analysis becomes even smarter. If that sounds like something you might be interested in, read on and see how the new checks are going to work. (more…)

It's been a while since we added the Analyze → Locate Duplicates feature. If you've had a chance to use it, you know how helpful it is: by eliminating duplicates in your code, you make it more concise and stable. If you've never used it, you definitely should; it's truly surprising how many duplicates an average codebase usually contains. The fresh IntelliJ IDEA 15 EAP build released today takes the duplicates analysis to an entirely new level by allowing you to spot them on-the-fly. Now, if you stumble upon an existing duplicate, or somehow create one either by writing or pasting code, you

One of the core principles of computer programming is eliminating manual repetition. Not only is repeated code time-consuming to read and review, it is disproportionately complex to maintain and provides a ready source of bugs when one copy changes. Yet in spite of this, duplicating some code in a large project may be inevitable. IntelliJ IDEA offers a powerful inspection for detecting and deduplicating repetitive code. You can activate this inspection by navigating to the menu entry Analyze|Locate Duplicates, or by pressing Ctrl/⌘+Alt/⌥+Shift+I then typing, "Duplicated Code." As it turns out

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

The release of JDK 8 has introduced a number of new language features into Java vernacular. In this issue of The Inspection Connection, we will examine eight useful inspections that IntelliJ IDEA provides to help you become more fluent in functional programming on Java 8, migrate your legacy code, detect bugs sooner, and develop with pleasure. 1. Anonymous type can be replaced with lambda As a Java developer, you are probably familiar with anonymous classes, which declare and instantiate themselves all at once. These classes will either implement an interface or override functionality by e

As we're closing in on the release date, we're going to publish more details on the new features of IntelliJ IDEA 13. Today we'd like to tell you about the new @Contract annotation. If you are aware of @Nullable/@NotNull annotations, you probably know how helpful they are against NullPointerException. The new @Contract annotation brings one more layer of safety for your code by defining dependencies between method arguments and return values. This information lets IntelliJ IDEA provide smarter control flow analysis for your code and avoid probable errors. Here’s an example: say we’ve got

We continue to publish new articles from the 30 Day Guide for learning the fundamental features of IntelliJ IDEA. Today we will talk about such basic thing as inspections. As you know inspections are built-in tools that help you find probable bugs, locate dead code, detect performance issues and improve the overall code structure. Navigate to the next/previous problem Did you know that you can quickly navigate between the highlighted problems within a file via shortcuts? Press F2 to go to the next problem and Shift + F2 to the previous one. If you press Ctrl + F1 (Cmd + F1 for Mac) the ID

As you might know IntelliJ IDEA 12 will bring support for new features of Java 8 language. Though this is still in progress, you can try some of these features now in IntelliJ IDEA 12 EAP. Here we would like to provide some details on method and constructor refereces support. IntelliJ IDEA as always provides a way to transform existing code to use new features. Dedicated inspection finds and highlights anonymous types which can be replaced with a method reference. After you apply provided quick-fix, it gets just a line of code. There is also another inspection that checks if a lambda e

In the latest IntelliJ IDEA 11.1 EAP we've added 2 new inspections that warn you about unknown attributes and tags in Android XML resource files and AndroidManifest.xml: IntelliJ IDEA can validate both system attributes and local ones defined in attrs.xml file in your project. Of course, you can disable or tune these inspections according to your needs in the IDE settings.

In IntelliJ IDEA 11.1 we've added many inspections based on Android Lint tool, which reports many kinds of potential problems in the sources of your Android project. For example IntelliJ IDEA will notify you about useless views in layout xml files and will offer to remove it: Another example is that IDE warns you about hardcoded text and offer to extract a new string resource: Some issues (such as duplicated icons or incomplete translations) aren't shown in the editor, but reported when you run inspections for your project. Simply launch Analyze | Inspect Code from the main menu: You ca

Have you ever cursed an API which uses magic integer constants instead of the proper enumeration? What should I pass as the titleJustification parameter here? 0 or 1? Can I pass "42" for the titlePosition parameter? Even Javadoc won't know. Actually, you must use one of the constants in the TitledBorder class to make the code correct: I call these constants "magic" because sometimes it is far from easy to figure them out. Here comes a new "Magic constant" inspection that looks for usages of methods/variables which expect "magic constants" as their arguments: Then it helps you to rep

In IntelliJ IDEA 11 you can check your Regular Expressions while coding without leaving the IDE. Just invoke the 'Check RegExp' intention action on a regular expression and play! Tip: You can turn any string into a regular expression by injecting RegExp language. Try the 'Inject Language' intention action.

Yes! The sunny Spring has finally come to St.Petersburg too. However, it's not that "Spring" we want to talk now... We realize that many of you use the Spring framework in your every day work. So, many should be interested in the new Spring-related features that can be found in the upcoming IntelliJ IDEA 10.5 release. 1. Better navigation between xml configs and annotated stereotype components 2. Advanced usage search for @Autowired beans 3. More inspections for your configs, for instance, deprecated classes and members highlighting. 4. More powerful placeholder support. All spring model

Sometimes it is helpful to use a Map for fast prototyping of classes with some properties but without any logic. But in the end it would be nice to have a real class. In IntelliJ IDEA you can get it by invoking "Convert Map to Class" intention on a map. You only need to type a name and a package for a new class: And you'll get something like this... and a UserInfo class: Quick and easy, right? It is not something new, it's been in IntelliJ IDEA for a while already. We just felt you might not be aware of it.

Java 7 provides a way to remove a compiler warning about generics vararg invocation. With Java 7 you can annotate your vararg method with SafeVararg annotation and your clients won't get these nasty warnings any more. IntelliJ IDEA 10.5 will help you to perform this migration. It will find for you all the places where @SafeVarargs annotation is applicable and suggest you to add this annotation. Of course, it will also check if existing @SafeVarargs annotations are applicable. Suppose you have annotated your method with @SafeVararg but already have suppressions for unchecked warning in clien

For quite a while IntelliJ IDEA can detect probable NPE’s in your code. But you have to annotate it with JetBrains' @Nullable/@NotNull. In order to leave your code free from JetBrains' annotations you could use external annotations, but they were not so convenient to use as they were not visible in the code. With libraries and SDK code, however, there is no other way except using the external annotations. So, to make things better, 10.5 IntelliJ IDEA will be able to recognize the most common annotations, such as javax @Nullable/@Nonnull, FindBugs @Nullable/@NonNull, as well as your own annota

For a long time already IntelliJ IDEA can detect probable NPE's in your code. You need to annotate your methods/fields/variables with @Nullable/@NotNull annotations and IntelliJ IDEA will highlight possible contract violations. Good. But the annotations only begin to work when there is enough of them in the code. You do need to annotate your code to get the benefits. IntelliJ IDEA 10 can do it for you. Just run Analyze | Infer Nullity... and choose a scope where you want annotations to be inferred. IntelliJ IDEA uses many rules to analyze nullity and make a decision. Here are just 2 examples

To run a single inspection in previous versions of IntelliJ IDEA you had to create a dedicated inspection profile for that or use "Run inspection on..." from inspection's quick fix list. In IntelliJ IDEA X you can find and run inspection by its name on any scope without creating an inspection profile. Use Run Inspection by Name (Ctrl+Alt+Shift+I) action anywhere to choose a desired inspection from hundreds of available, then select a scope to run inspection on, and get results. This action is available since version 98.402 in Main Menu-> Analyze->Run Inspection by Name.

How many times you wished you could edit your last VCS commit comment to correct a misspelling? Now you will notice such mistakes because IntelliJ IDEA 10 checks the spelling in the comment field. And it not just spellchecks the text, it runs the Spelling inspection on it and uses your custom dictionary too. Hit Alt+Enter/⌥↩ on an underlined word and fix it as you normally fix things in IntelliJ IDEA code editor. Spellchecker is also enabled in other dialogs throughout the IDE, e.g. Search/Replace dialog. Try IntelliJ IDEA X EAP and let us know your impressions.