Merge remote branch 'origin/master'

.idea/modules.xml

@@ -10,6 +10,7 @@
       <module fileurl="file://$PROJECT_DIR$/plugins/IntentionPowerPak/IntentionPowerPackPlugin.iml" filepath="$PROJECT_DIR$/plugins/IntentionPowerPak/IntentionPowerPackPlugin.iml" group="plugins" />
       <module fileurl="file://$PROJECT_DIR$/RegExpSupport/RegExpSupport.iml" filepath="$PROJECT_DIR$/RegExpSupport/RegExpSupport.iml" />
       <module fileurl="file://$PROJECT_DIR$/plugins/android/android.iml" filepath="$PROJECT_DIR$/plugins/android/android.iml" group="plugins/Android" />
+      <module fileurl="file://$PROJECT_DIR$/plugins/android/common/android-common.iml" filepath="$PROJECT_DIR$/plugins/android/common/android-common.iml" group="plugins/Android" />
       <module fileurl="file://$PROJECT_DIR$/plugins/android/jps-plugin/android-jps-plugin.iml" filepath="$PROJECT_DIR$/plugins/android/jps-plugin/android-jps-plugin.iml" group="plugins/Android" />
       <module fileurl="file://$PROJECT_DIR$/plugins/android/rt/android-rt.iml" filepath="$PROJECT_DIR$/plugins/android/rt/android-rt.iml" group="plugins/Android" />
       <module fileurl="file://$PROJECT_DIR$/platform/annotations/annotations.iml" filepath="$PROJECT_DIR$/platform/annotations/annotations.iml" group="platform" />

build/scripts/layouts.gant

@@ -383,7 +383,10 @@ public def layoutCommunityPlugins(String home) {
         exclude(name: "**/ddmlib_1.jar")
       }
 
-      jar("android_rt.jar") {module("android-rt")}
+      jar("android-common.jar") {
+        module("android-rt")
+        module("android-common")
+      }
 
       dir("jps") {
         jar("android-jps-plugin.jar") { module("android-jps-plugin") }

java/debugger/impl/src/com/intellij/debugger/ui/DebuggerEditorImpl.java

@@ -69,13 +69,13 @@ public abstract class DebuggerEditorImpl extends CompletionEditor{
   private WeakReference<ListPopup> myPopup;
 
   private final PsiTreeChangeListener myPsiListener = new PsiTreeChangeAdapter() {
-    public void childRemoved(PsiTreeChangeEvent event) {
+    public void childRemoved(@NotNull PsiTreeChangeEvent event) {
       checkContext();
     }
-    public void childReplaced(PsiTreeChangeEvent event) {
+    public void childReplaced(@NotNull PsiTreeChangeEvent event) {
       checkContext();
     }
-    public void childMoved(PsiTreeChangeEvent event) {
+    public void childMoved(@NotNull PsiTreeChangeEvent event) {
       checkContext();
     }
     private void checkContext() {

java/execution/impl/src/com/intellij/execution/junit2/segments/Extractor.java

@@ -30,6 +30,7 @@ import org.jetbrains.annotations.NotNull;
 import java.io.InputStream;
 import java.io.Reader;
 import java.nio.charset.Charset;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * @author dyoma
@@ -40,7 +41,7 @@ public class Extractor implements Disposable {
   private OutputPacketProcessor myEventsDispatcher;
   private static final Logger LOG = Logger.getInstance("#" + Extractor.class.getName());
   private final MergingUpdateQueue myQueue = new MergingUpdateQueue("Test Extractor", 20, true, MergingUpdateQueue.ANY_COMPONENT);
-  private int myOrder = -1;
+  private AtomicInteger myOrder = new AtomicInteger(-1);
 
   public Extractor(@NotNull InputStream stream, @NotNull Charset charset) {
     myStream = new SegmentedInputStream(stream, charset);
@@ -66,7 +67,7 @@ public class Extractor implements Disposable {
     myFulfilledWorkGate = new DeferredActionsQueue() { //todo make it all later
       @Override
       public void addLast(final Runnable runnable) {
-        myQueue.queue(new MyUpdate(runnable, queue, myOrder++));
+        myQueue.queue(new MyUpdate(runnable, queue, myOrder.incrementAndGet()));
       }
 
       @Override

java/idea-ui/src/com/intellij/util/descriptors/impl/ConfigFileImpl.java

@@ -33,11 +33,11 @@ public class ConfigFileImpl implements ConfigFile {
     final VirtualFilePointerManager pointerManager = VirtualFilePointerManager.getInstance();
     myFilePointer = pointerManager.create(configuration.getUrl(), this, new VirtualFilePointerListener() {
       @Override
-      public void beforeValidityChanged(final VirtualFilePointer[] pointers) {
+      public void beforeValidityChanged(@NotNull final VirtualFilePointer[] pointers) {
       }
 
       @Override
-      public void validityChanged(final VirtualFilePointer[] pointers) {
+      public void validityChanged(@NotNull final VirtualFilePointer[] pointers) {
         myPsiFile = null;
         onChange();
       }

java/java-impl/src/com/intellij/codeInsight/ExpectedTypesProvider.java

@@ -576,7 +576,7 @@ public class ExpectedTypesProvider {
     @Override
     public void visitPolyadicExpression(PsiPolyadicExpression expr) {
       PsiExpression[] operands = expr.getOperands();
-      int index = Arrays.asList(operands).indexOf(myExpr);
+      final int index = Arrays.asList(operands).indexOf(myExpr);
       assert index >= 0;
 
       if (myForCompletion && index == 0) {
@@ -591,7 +591,7 @@ public class ExpectedTypesProvider {
         }
         return;
       }
-      PsiExpression anotherExpr = index > 0 ? operands[0] : index < operands.length ? operands[1] : null;
+      PsiExpression anotherExpr = index > 0 ? operands[0] : 1 < operands.length ? operands[1] : null;
       PsiType anotherType = anotherExpr != null ? anotherExpr.getType() : null;
       IElementType i = expr.getOperationTokenType();
       if (i == JavaTokenType.MINUS ||

java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java

@@ -65,6 +65,7 @@ import com.intellij.psi.xml.XmlDocument;
 import com.intellij.psi.xml.XmlFile;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.*;
+import com.intellij.util.containers.ConcurrentWeakHashMap;
 import com.intellij.util.containers.ConcurrentWeakValueHashMap;
 import com.intellij.util.messages.MessageBusConnection;
 import com.intellij.util.ui.OptionsMessageDialog;
@@ -135,9 +136,20 @@ public class ExternalAnnotationsManagerImpl extends ExternalAnnotationsManager {
     return result.isEmpty() ? null : result.values().toArray(new PsiAnnotation[result.size()]);
   }
 
+  private final Map<PsiModifierListOwner, Map<String, PsiAnnotation>> cache = new ConcurrentWeakHashMap<PsiModifierListOwner, Map<String, PsiAnnotation>>();
   @NotNull
   private Map<String, PsiAnnotation> collectExternalAnnotations(@NotNull final PsiModifierListOwner listOwner) {
     if (hasAnyAnnotationsRoots() == ThreeState.NO) return Collections.emptyMap();
+
+    Map<String, PsiAnnotation> map = cache.get(listOwner);
+    if (map == null) {
+      map = doCollect(listOwner);
+      cache.put(listOwner, map);
+    }
+    return map;
+  }
+
+  private Map<String, PsiAnnotation> doCollect(@NotNull PsiModifierListOwner listOwner) {
     final List<XmlFile> files = findExternalAnnotationsFiles(listOwner);
     if (files == null) {
       return Collections.emptyMap();
@@ -313,10 +325,12 @@ public class ExternalAnnotationsManagerImpl extends ExternalAnnotationsManager {
     return VfsUtil.toVirtualFileArray(result);
   }
 
-  private void annotateExternally(@NotNull final VirtualFile file, @NotNull final PsiModifierListOwner listOwner, final Project project,
+  private void annotateExternally(@NotNull final VirtualFile file,
+                                  @NotNull final PsiModifierListOwner listOwner,
+                                  @NotNull Project project,
                                   @NotNull final String packageName,
                                   final VirtualFile virtualFile,
-                                  final String annotationFQName,
+                                  @NotNull final String annotationFQName,
                                   @NotNull final PsiFile fromFile,
                                   final PsiNameValuePair[] value) {
     final XmlFile[] annotationsXml = new XmlFile[1];
@@ -352,46 +366,61 @@ public class ExternalAnnotationsManagerImpl extends ExternalAnnotationsManager {
 
   @Override
   public boolean deannotate(@NotNull final PsiModifierListOwner listOwner, @NotNull final String annotationFQN) {
-    final List<XmlFile> files = findExternalAnnotationsFiles(listOwner);
-    if (files != null) {
+    try {
+      final List<XmlFile> files = findExternalAnnotationsFiles(listOwner);
+      if (files == null) {
+        return false;
+      }
       for (XmlFile file : files) {
-        if (file.isValid()) {
-          final XmlDocument document = file.getDocument();
-          if (document != null) {
-            final XmlTag rootTag = document.getRootTag();
-            if (rootTag != null) {
-              final String externalName = getExternalName(listOwner, false);
-              final String oldExternalName = getNormalizedExternalName(listOwner);
-              for (final XmlTag tag : rootTag.getSubTags()) {
-                final String className = tag.getAttributeValue("name");
-                if (Comparing.strEqual(className, externalName) || Comparing.strEqual(className, oldExternalName)) {
-                  for (XmlTag annotationTag : tag.getSubTags()) {
-                    if (Comparing.strEqual(annotationTag.getAttributeValue("name"), annotationFQN)) {
-                      if (ReadonlyStatusHandler.getInstance(myPsiManager.getProject())
-                        .ensureFilesWritable(file.getVirtualFile()).hasReadonlyFiles()) {
-                        return false;
-                      }
-                      try {
-                        annotationTag.delete();
-                        if (tag.getSubTags().length == 0) {
-                          tag.delete();
-                        }
-                      }
-                      catch (IncorrectOperationException e) {
-                        LOG.error(e);
-                      }
-                      return true;
-                    }
-                  }
-                  return false;
-                }
+        if (!file.isValid()) {
+          continue;
+        }
+        final XmlDocument document = file.getDocument();
+        if (document == null) {
+          continue;
+        }
+        final XmlTag rootTag = document.getRootTag();
+        if (rootTag == null) {
+          continue;
+        }
+        final String externalName = getExternalName(listOwner, false);
+        final String oldExternalName = getNormalizedExternalName(listOwner);
+        for (final XmlTag tag : rootTag.getSubTags()) {
+          final String className = tag.getAttributeValue("name");
+          if (!Comparing.strEqual(className, externalName) && !Comparing.strEqual(className, oldExternalName)) {
+            continue;
+          }
+          for (XmlTag annotationTag : tag.getSubTags()) {
+            if (!Comparing.strEqual(annotationTag.getAttributeValue("name"), annotationFQN)) {
+              continue;
+            }
+            if (ReadonlyStatusHandler.getInstance(myPsiManager.getProject())
+              .ensureFilesWritable(file.getVirtualFile()).hasReadonlyFiles()) {
+              return false;
+            }
+            try {
+              annotationTag.delete();
+              if (tag.getSubTags().length == 0) {
+                tag.delete();
               }
             }
+            catch (IncorrectOperationException e) {
+              LOG.error(e);
+            }
+            return true;
           }
+          return false;
         }
       }
+      return false;
     }
-    return false;
+    finally {
+      dropCache();
+    }
+  }
+
+  private void dropCache() {
+    cache.clear();
   }
 
   @Override
@@ -481,11 +510,11 @@ public class ExternalAnnotationsManagerImpl extends ExternalAnnotationsManager {
     myExternalAnnotations.clear();
   }
 
-  private void annotateExternally(final PsiModifierListOwner listOwner,
-                                         final String annotationFQName,
-                                         @Nullable final XmlFile xmlFile,
-                                         @NotNull PsiFile codeUsageFile,
-                                         PsiNameValuePair[] values) {
+  private void annotateExternally(@NotNull PsiModifierListOwner listOwner,
+                                  @NotNull String annotationFQName,
+                                  @Nullable final XmlFile xmlFile,
+                                  @NotNull PsiFile codeUsageFile,
+                                  PsiNameValuePair[] values) {
     if (xmlFile == null) return;
     try {
       final XmlDocument document = xmlFile.getDocument();
@@ -518,6 +547,7 @@ public class ExternalAnnotationsManagerImpl extends ExternalAnnotationsManager {
       LOG.error(e);
     }
     finally {
+      dropCache();
       if (codeUsageFile.getVirtualFile().isInLocalFileSystem()) {
         UndoUtil.markPsiFileForUndo(codeUsageFile);
       }
@@ -525,7 +555,8 @@ public class ExternalAnnotationsManagerImpl extends ExternalAnnotationsManager {
   }
 
   @NonNls
-  private static String createAnnotationTag(String annotationFQName, @Nullable PsiNameValuePair[] values) {
+  @NotNull
+  private static String createAnnotationTag(@NotNull String annotationFQName, @Nullable PsiNameValuePair[] values) {
     @NonNls String text;
     if (values != null) {
       text = "  <annotation name=\'" + annotationFQName + "\'>\n";

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateConstructorParameterFromFieldFix.java

@@ -150,7 +150,8 @@ public class CreateConstructorParameterFromFieldFix implements IntentionAction {
       final Collection<SmartPsiElementPointer<PsiField>> fieldsToFix = getFieldsToFix();
       try {
         final PsiMethod constructor = constrs.get(0);
-        final List<PsiField> fields = new ArrayList<PsiField>();
+        final LinkedHashSet<PsiField> fields = new LinkedHashSet<PsiField>();
+        getFieldsToFix().add(myField);
         for (SmartPsiElementPointer<PsiField> elementPointer : fieldsToFix) {
           final PsiField field = elementPointer.getElement();
           if (field != null && isAvailable(field) && filterConstructorsIfFieldAlreadyAssigned(new PsiMethod[]{constructor}, field).contains(constructor)) {

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateInnerClassFromUsageFix.java

@@ -16,9 +16,6 @@
 package com.intellij.codeInsight.daemon.impl.quickfix;
 
 import com.intellij.codeInsight.daemon.QuickFixBundle;
-import static com.intellij.codeInsight.daemon.impl.quickfix.CreateClassKind.CLASS;
-import static com.intellij.codeInsight.daemon.impl.quickfix.CreateClassKind.INTERFACE;
-
 import com.intellij.ide.util.PsiClassListCellRenderer;
 import com.intellij.ide.util.PsiElementListCellRenderer;
 import com.intellij.openapi.application.ApplicationManager;
@@ -37,6 +34,9 @@ import javax.swing.*;
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.intellij.codeInsight.daemon.impl.quickfix.CreateClassKind.CLASS;
+import static com.intellij.codeInsight.daemon.impl.quickfix.CreateClassKind.INTERFACE;
+
 /**
  * @author ven
  */
@@ -78,7 +78,7 @@ public class CreateInnerClassFromUsageFix extends CreateClassFromUsageBaseFix {
     PsiMember contextMember = PsiTreeUtil.getParentOfType(run, PsiMember.class);
 
     while (contextMember != null) {
-      if (contextMember instanceof PsiClass) {
+      if (contextMember instanceof PsiClass && !(contextMember instanceof PsiTypeParameter)) {
         result.add((PsiClass)contextMember);
       }
       run = contextMember;

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreatePropertyFromUsageFix.java

@@ -247,6 +247,7 @@ public class CreatePropertyFromUsageFix extends CreateFromUsageBaseFix {
     builder.setEndVariableAfter(body.getLBrace());
 
     accessor = CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(accessor);
+    LOG.assertTrue(accessor != null);
     targetClass = accessor.getContainingClass();
     LOG.assertTrue(targetClass != null);
     Template template = builder.buildTemplate();

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/DelegateWithDefaultParamValueIntentionAction.java

@@ -30,11 +30,14 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.refactoring.util.RefactoringUtil;
 import com.intellij.util.Function;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 
 import javax.swing.*;
+import java.util.Arrays;
+import java.util.HashSet;
 
 /**
  * User: anna
@@ -84,7 +87,7 @@ public class DelegateWithDefaultParamValueIntentionAction extends PsiElementBase
     final PsiParameter parameter = PsiTreeUtil.getParentOfType(element, PsiParameter.class);
     final PsiMethod method = (PsiMethod)parameter.getDeclarationScope();
     final PsiMethod prototype = (PsiMethod)method.getContainingClass().addBefore(generateMethodPrototype(method, parameter), method);
-
+    RefactoringUtil.fixJavadocsForParams(prototype, new HashSet<PsiParameter>(Arrays.asList(prototype.getParameterList().getParameters())));
     TemplateBuilderImpl builder = new TemplateBuilderImpl(prototype);
 
     PsiCodeBlock body = prototype.getBody();

java/java-impl/src/com/intellij/codeInspection/accessStaticViaInstance/AccessStaticViaInstance.java

@@ -19,6 +19,7 @@ import com.intellij.codeInsight.daemon.JavaErrorMessages;
 import com.intellij.codeInsight.daemon.impl.analysis.HighlightMessageUtil;
 import com.intellij.codeInsight.daemon.impl.analysis.HighlightUtil;
 import com.intellij.codeInsight.daemon.impl.quickfix.AccessStaticViaInstanceFix;
+import com.intellij.codeInsight.daemon.impl.quickfix.RemoveUnusedVariableFix;
 import com.intellij.codeInspection.BaseJavaLocalInspectionTool;
 import com.intellij.codeInspection.InspectionsBundle;
 import com.intellij.codeInspection.ProblemsHolder;
@@ -26,6 +27,8 @@ import com.intellij.psi.*;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
+
 /**
  * User: anna
  * Date: 15-Nov-2005
@@ -87,6 +90,12 @@ public class AccessStaticViaInstance extends BaseJavaLocalInspectionTool {
     String description = JavaErrorMessages.message("static.member.accessed.via.instance.reference",
                                                    HighlightUtil.formatType(qualifierExpression.getType()),
                                                    HighlightMessageUtil.getSymbolName(resolved, result.getSubstitutor()));
+    if (!onTheFly) {
+      if (RemoveUnusedVariableFix.checkSideEffects(qualifierExpression, null, new ArrayList<PsiElement>())) {
+        holder.registerProblem(expr, description);
+        return;
+      }
+    }
     holder.registerProblem(expr, description, new AccessStaticViaInstanceFix(expr, result, onTheFly));
   }
 }

java/java-impl/src/com/intellij/codeInspection/defaultFileTemplateUsage/MethodBodyChecker.java

@@ -27,12 +27,13 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.Pair;
-import com.intellij.openapi.util.UserDataHolderEx;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleManager;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.reference.SoftReference;
 import com.intellij.util.IncorrectOperationException;
+import com.intellij.util.PatchedSoftReference;
 import com.intellij.util.containers.ConcurrentHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -75,12 +76,13 @@ public class MethodBodyChecker {
     }
   }
 
-  private static final Key<Map<String, PsiMethod>> CACHE_KEY = new Key<Map<String, PsiMethod>>("MethodBodyChecker templates cache");
+  private static final Key<SoftReference<Map<String, PsiMethod>>> CACHE_KEY = Key.create("MethodBodyChecker templates cache");
 
   private static Map<String, PsiMethod> getTemplatesCache(PsiClass aClass) {
-    Map<String, PsiMethod> cache = aClass.getUserData(CACHE_KEY);
+    SoftReference<Map<String, PsiMethod>> ref = aClass.getUserData(CACHE_KEY);
+    Map<String, PsiMethod> cache = ref == null ? null : ref.get();
     if (cache == null) {
-      cache = ((UserDataHolderEx)aClass).putUserDataIfAbsent(CACHE_KEY, new ConcurrentHashMap<String, PsiMethod>());
+      aClass.putUserData(CACHE_KEY, new PatchedSoftReference<Map<String, PsiMethod>>(cache = new ConcurrentHashMap<String, PsiMethod>()));
     }
     return cache;
   }

java/java-impl/src/com/intellij/codeInspection/magicConstant/MagicCompletionContributor.java

@@ -174,7 +174,8 @@ public class MagicCompletionContributor extends CompletionContributor {
       @Override
       public void consume(CompletionResult completionResult) {
         LookupElement element = completionResult.getLookupElement();
-        if (allowed.contains(element.getObject())) {
+        Object object = element.getObject();
+        if (object instanceof PsiElement && allowed.contains(object)) {
           return;
         }
         result.passResult(completionResult);

java/java-impl/src/com/intellij/refactoring/OptimizeImportsRefactoringHelper.java

@@ -104,10 +104,17 @@ public class OptimizeImportsRefactoringHelper implements RefactoringHelper<Set<P
             if (importStatement != null && importStatement.isValid()) {
               final PsiJavaCodeReferenceElement ref = importStatement.getImportReference();
               //Do not remove non-resolving refs
-              if (ref == null || ref.resolve() == null) {
+              if (ref == null) {
+                continue;
+              }
+              final PsiElement resolve = ref.resolve();
+              if (resolve == null) {
                 continue;
               }
 
+              if (resolve instanceof PsiPackage && ((PsiPackage)resolve).getDirectories(ref.getResolveScope()).length == 0) {
+                continue;
+              }
               importStatement.delete();
             }
           }

java/java-impl/src/com/intellij/refactoring/anonymousToInner/AnonymousToInnerDialog.java

@@ -24,6 +24,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
 import com.intellij.psi.codeStyle.VariableKind;
+import com.intellij.psi.util.TypeConversionUtil;
 import com.intellij.refactoring.HelpID;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.ui.NameSuggestionsField;
@@ -86,10 +87,14 @@ class AnonymousToInnerDialog extends DialogWrapper{
     if (typeParameters.length > 0) {
       names = new String[]{StringUtil.join(typeParameters, new Function<PsiType, String>() {
         public String fun(PsiType psiType) {
+          PsiType type = psiType;
           if (psiType instanceof PsiClassType) {
-            return ((PsiClassType)psiType).rawType().getPresentableText();
+            type = TypeConversionUtil.erasure(psiType);
           }
-          return psiType.getPresentableText();
+          if (type instanceof PsiArrayType) {
+            type = type.getDeepComponentType();
+          }
+          return type.getPresentableText();
         }
       }, "") + name, "My" + name};
     } else {

java/java-impl/src/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureProcessor.java

@@ -72,6 +72,7 @@ public class ChangeClassSignatureProcessor extends BaseRefactoringProcessor {
       if (reference.getElement() instanceof PsiJavaCodeReferenceElement) {
         PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)reference.getElement();
         PsiElement parent = referenceElement.getParent();
+        if (parent instanceof PsiTypeElement && parent.getParent() instanceof PsiInstanceOfExpression) continue;
         if (parent instanceof PsiTypeElement || parent instanceof PsiNewExpression || parent instanceof PsiAnonymousClass ||
             parent instanceof PsiReferenceList) {
           if (!hadTypeParameters || referenceElement.getTypeParameters().length > 0) {

java/java-impl/src/com/intellij/refactoring/copy/CopyClassesHandler.java

@@ -298,7 +298,7 @@ public class CopyClassesHandler extends CopyHandlerDelegateBase {
 
   @Nullable
   public static PsiElement doCopyClasses(final Map<PsiFile, PsiClass[]> fileToClasses,
-                                         HashMap<PsiFile, String> map, final String copyClassName,
+                                         @Nullable HashMap<PsiFile, String> map, final String copyClassName,
                                          final PsiDirectory targetDirectory,
                                          final Project project) throws IncorrectOperationException {
     PsiElement newElement = null;
@@ -345,8 +345,12 @@ public class CopyClassesHandler extends CopyHandlerDelegateBase {
     
     for (PsiFile file : files) {
       try {
-        final PsiFile fileCopy =
-          CopyFilesOrDirectoriesHandler.copyToDirectory(file, getNewFileName(file, copyClassName), targetDirectory, choice);
+        PsiDirectory finalTarget = targetDirectory;
+        final String relativePath = map != null ? map.get(file) : null;
+        if (relativePath != null && !relativePath.isEmpty()) {
+          finalTarget = buildRelativeDir(targetDirectory, relativePath).findOrCreateTargetDirectory();
+        }
+        final PsiFile fileCopy = CopyFilesOrDirectoriesHandler.copyToDirectory(file, getNewFileName(file, copyClassName), finalTarget, choice);
         if (fileCopy != null) {
           createdFiles.add(fileCopy);
         }

java/java-impl/src/com/intellij/refactoring/introduceField/BaseExpressionToFieldHandler.java

@@ -218,9 +218,9 @@ public abstract class BaseExpressionToFieldHandler extends IntroduceHandlerBase
     return false;
   }
 
-  public static void setModifiers(PsiField field, Settings settings, final boolean declareStatic) {
+  public static void setModifiers(PsiField field, Settings settings) {
     if (!settings.isIntroduceEnumConstant()) {
-      if (declareStatic) {
+      if (settings.isDeclareStatic()) {
         PsiUtil.setModifierProperty(field, PsiModifier.STATIC, true);
       }
       if (settings.isDeclareFinal()) {
@@ -711,7 +711,7 @@ public abstract class BaseExpressionToFieldHandler extends IntroduceHandlerBase
                          createField(myFieldName, myType, initializer, initializerPlace == InitializationPlace.IN_FIELD_DECLARATION && initializer != null,
                                      myParentClass);
 
-        setModifiers(myField, mySettings, mySettings.isDeclareStatic());
+        setModifiers(myField, mySettings);
         myField = appendField(initializer, initializerPlace, destClass, myParentClass, myAnchorElement, myField);
         if (!mySettings.isIntroduceEnumConstant()) {
           VisibilityUtil.fixVisibility(myOccurrences, myField, mySettings.getFieldVisibility());

java/java-impl/src/com/intellij/refactoring/introduceField/IntroduceFieldHandler.java

@@ -31,6 +31,8 @@ import com.intellij.refactoring.util.CommonRefactoringUtil;
 import com.intellij.refactoring.util.occurrences.*;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+
 public class IntroduceFieldHandler extends BaseExpressionToFieldHandler {
 
   public static final String REFACTORING_NAME = RefactoringBundle.message("introduce.field.title");
@@ -199,10 +201,19 @@ public class IntroduceFieldHandler extends BaseExpressionToFieldHandler {
         final PsiStatement statement = PsiTreeUtil.getParentOfType(local, PsiStatement.class);
         return IntroduceFieldHandler.this.showRefactoringDialog(project, editor, aClass, local.getInitializer(), local.getType(), occurences, local, statement);
       }
+
+      @Override
+      protected int getChosenClassIndex(List<PsiClass> classes) {
+        return IntroduceFieldHandler.this.getChosenClassIndex(classes);
+      }
     };
     return localToFieldHandler.convertLocalToField(localVariable, editor);
   }
 
+  protected int getChosenClassIndex(List<PsiClass> classes) {
+    return classes.size() - 1;
+  }
+
   private static class MyOccurrenceFilter implements OccurrenceFilter {
     public boolean isOK(PsiExpression occurrence) {
       return !isInSuperOrThis(occurrence);

java/java-impl/src/com/intellij/refactoring/introduceField/LocalToFieldHandler.java

@@ -81,7 +81,7 @@ public abstract class LocalToFieldHandler {
 
     if (classes.isEmpty()) return false;
     if (classes.size() == 1 || ApplicationManager.getApplication().isUnitTestMode()) {
-      if (convertLocalToField(local, classes.get(classes.size() - 1), editor, tempIsStatic)) return false;
+      if (convertLocalToField(local, classes.get(getChosenClassIndex(classes)), editor, tempIsStatic)) return false;
     } else {
       final boolean isStatic = tempIsStatic;
       NavigationUtil.getPsiElementPopup(classes.toArray(new PsiClass[classes.size()]), new PsiClassListCellRenderer(), "Choose class to introduce " + (myIsConstant ? "constant" : "field"), new PsiElementProcessor<PsiClass>() {
@@ -96,6 +96,10 @@ public abstract class LocalToFieldHandler {
     return true;
   }
 
+  protected int getChosenClassIndex(List<PsiClass> classes) {
+    return classes.size() - 1;
+  }
+
   private boolean convertLocalToField(PsiLocalVariable local, PsiClass aClass, Editor editor, boolean isStatic) {
     final PsiExpression[] occurences = CodeInsightUtil.findReferenceExpressions(RefactoringUtil.getVariableScope(local), local);
     if (editor != null) {
@@ -250,7 +254,6 @@ public abstract class LocalToFieldHandler {
     private final PsiClass myDestinationClass;
     private final BaseExpressionToFieldHandler.Settings mySettings;
     private final BaseExpressionToFieldHandler.InitializationPlace myInitializerPlace;
-    private final boolean myStatic;
     private final PsiExpression[] myOccurences;
     private PsiField myField;
     private PsiStatement myAssignmentStatement;
@@ -269,7 +272,6 @@ public abstract class LocalToFieldHandler {
       myDestinationClass = aClass;
       mySettings = settings;
       myInitializerPlace = settings.getInitializerPlace();
-      myStatic = isStatic;
       myOccurences = occurrences;
     }
 
@@ -288,7 +290,7 @@ public abstract class LocalToFieldHandler {
         myField = mySettings.isIntroduceEnumConstant() ? EnumConstantsUtil.createEnumConstant(myDestinationClass, myLocal, myFieldName)
                                                        : createField(myLocal, mySettings.getForcedType(), myFieldName, myInitializerPlace == IN_FIELD_DECLARATION);
         myField = (PsiField)myDestinationClass.add(myField);
-        BaseExpressionToFieldHandler.setModifiers(myField, mySettings, myStatic);
+        BaseExpressionToFieldHandler.setModifiers(myField, mySettings);
         if (!mySettings.isIntroduceEnumConstant()) {
           VisibilityUtil.fixVisibility(myOccurences, myField, mySettings.getFieldVisibility());
         }

java/java-impl/src/com/intellij/refactoring/introduceParameter/AbstractJavaInplaceIntroducer.java

@@ -99,6 +99,7 @@ public abstract class AbstractJavaInplaceIntroducer extends AbstractInplaceIntro
   @Override
   protected void saveSettings(@NotNull PsiVariable psiVariable) {
     TypeSelectorManagerImpl.typeSelected(psiVariable.getType(), getType());//myDefaultType.getType());
+    myTypeSelectorManager = null;
   }
 
   public PsiType getType() {

java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesProcessor.java

@@ -27,10 +27,7 @@ import com.intellij.psi.*;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.PackageScope;
 import com.intellij.psi.search.searches.ReferencesSearch;
-import com.intellij.psi.util.MethodSignatureUtil;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtil;
-import com.intellij.psi.util.PsiUtilBase;
+import com.intellij.psi.util.*;
 import com.intellij.refactoring.BaseRefactoringProcessor;
 import com.intellij.refactoring.MoveDestination;
 import com.intellij.refactoring.PackageWrapper;
@@ -68,16 +65,15 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor {
   private boolean mySearchInNonJavaFiles;
   private final PackageWrapper myTargetPackage;
   private final MoveCallback myMoveCallback;
-  protected final MoveDestination myMoveDestination;
+  protected @NotNull final MoveDestination myMoveDestination;
   protected NonCodeUsageInfo[] myNonCodeUsages;
 
-  public MoveClassesOrPackagesProcessor(
-    Project project,
-    PsiElement[] elements,
-    final MoveDestination moveDestination,
-    boolean searchInComments,
-    boolean searchInNonJavaFiles,
-    MoveCallback moveCallback) {
+  public MoveClassesOrPackagesProcessor(Project project,
+                                        PsiElement[] elements,
+                                        @NotNull final MoveDestination moveDestination,
+                                        boolean searchInComments,
+                                        boolean searchInNonJavaFiles,
+                                        MoveCallback moveCallback) {
     super(project);
     final Set<PsiElement> toMove = new LinkedHashSet<PsiElement>();
     for (PsiElement element : elements) {
@@ -87,7 +83,7 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor {
         toMove.add(element);
       }
     }
-    myElementsToMove = PsiUtilBase.toPsiElementArray(toMove);
+    myElementsToMove = PsiUtilCore.toPsiElementArray(toMove);
     Arrays.sort(myElementsToMove, new Comparator<PsiElement>() {
       @Override
       public int compare(PsiElement o1, PsiElement o2) {
@@ -451,7 +447,8 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor {
           if (allClasses.containsKey(psiClass)) {
             continue;
           }
-          final PsiClass[] classes = ((PsiClassOwner)element.getContainingFile()).getClasses();
+          final PsiClassOwner containingFile = (PsiClassOwner)element.getContainingFile();
+          final PsiClass[] classes = containingFile.getClasses();
           boolean all = true;
           for (PsiClass aClass : classes) {
             if (ArrayUtil.find(myElementsToMove, aClass) == -1) {
@@ -464,14 +461,14 @@ public class MoveClassesOrPackagesProcessor extends BaseRefactoringProcessor {
           }
         }
       }
-      Map<PsiElement, PsiElement> oldToNewElementsMapping = new HashMap<PsiElement, PsiElement>();
+      final Map<PsiElement, PsiElement> oldToNewElementsMapping = new HashMap<PsiElement, PsiElement>();
       for (int idx = 0; idx < myElementsToMove.length; idx++) {
         PsiElement element = myElementsToMove[idx];
         final RefactoringElementListener elementListener = getTransaction().getElementListener(element);
         if (element instanceof PsiPackage) {
           final PsiDirectory[] directories = ((PsiPackage)element).getDirectories();
-          final PsiPackage newElement =
-          MoveClassesOrPackagesUtil.doMovePackage((PsiPackage)element, myMoveDestination);
+          final PsiPackage newElement = MoveClassesOrPackagesUtil.doMovePackage((PsiPackage)element, myMoveDestination);
+          LOG.assertTrue(newElement != null);
           oldToNewElementsMapping.put(element, newElement);
           int i = 0;
           final PsiDirectory[] newDirectories = newElement.getDirectories();

java/java-impl/src/com/intellij/refactoring/move/moveClassesOrPackages/MoveClassesOrPackagesUtil.java

@@ -15,7 +15,6 @@
  */
 package com.intellij.refactoring.move.moveClassesOrPackages;
 
-import com.intellij.ide.util.DirectoryChooser;
 import com.intellij.ide.util.DirectoryChooserUtil;
 import com.intellij.lang.java.JavaFindUsagesProvider;
 import com.intellij.openapi.application.ApplicationManager;
@@ -23,7 +22,6 @@ import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.roots.ProjectRootManager;
-import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VfsUtil;
@@ -231,6 +229,7 @@ public class MoveClassesOrPackagesUtil {
 
     newClass = aClass;
     if (!moveDestination.equals(file.getContainingDirectory())) {
+      LOG.assertTrue(file.getVirtualFile() != null, aClass);
       MoveFilesOrDirectoriesUtil.doMoveFile(file, moveDestination);
       if (file instanceof PsiClassOwner && newPackage != null) {
         ((PsiClassOwner)file).setPackageName(newPackage.getQualifiedName());

java/java-impl/src/com/intellij/slicer/SliceManager.java

@@ -65,32 +65,32 @@ public class SliceManager implements PersistentStateComponent<SliceManager.Store
 
     psiManager.addPsiTreeChangeListener(new PsiTreeChangeAdapter() {
       @Override
-      public void beforeChildAddition(PsiTreeChangeEvent event) {
+      public void beforeChildAddition(@NotNull PsiTreeChangeEvent event) {
         cancel();
       }
 
       @Override
-      public void beforeChildRemoval(PsiTreeChangeEvent event) {
+      public void beforeChildRemoval(@NotNull PsiTreeChangeEvent event) {
         cancel();
       }
 
       @Override
-      public void beforeChildReplacement(PsiTreeChangeEvent event) {
+      public void beforeChildReplacement(@NotNull PsiTreeChangeEvent event) {
         cancel();
       }
 
       @Override
-      public void beforeChildMovement(PsiTreeChangeEvent event) {
+      public void beforeChildMovement(@NotNull PsiTreeChangeEvent event) {
         cancel();
       }
 
       @Override
-      public void beforeChildrenChange(PsiTreeChangeEvent event) {
+      public void beforeChildrenChange(@NotNull PsiTreeChangeEvent event) {
         cancel();
       }
 
       @Override
-      public void beforePropertyChange(PsiTreeChangeEvent event) {
+      public void beforePropertyChange(@NotNull PsiTreeChangeEvent event) {
         cancel();
       }
     }, project);

java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/JavaResolveCache.java

@@ -26,22 +26,19 @@ import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.NotNullLazyKey;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.AnyPsiChangeListener;
-import com.intellij.psi.impl.DebugUtil;
-import com.intellij.psi.impl.PsiManagerEx;
 import com.intellij.psi.impl.PsiManagerImpl;
 import com.intellij.psi.impl.source.PsiClassReferenceType;
-import com.intellij.psi.impl.source.tree.TreeElement;
 import com.intellij.psi.util.TypeConversionUtil;
+import com.intellij.reference.SoftReference;
 import com.intellij.util.ConcurrencyUtil;
 import com.intellij.util.Function;
-import com.intellij.util.Processor;
 import com.intellij.util.containers.ConcurrentWeakHashMap;
-import com.intellij.util.containers.WeakHashMap;
-import com.intellij.util.containers.WeakList;
 import com.intellij.util.messages.MessageBus;
+import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.lang.ref.Reference;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentMap;
@@ -55,11 +52,7 @@ public class JavaResolveCache {
     return INSTANCE_KEY.getValue(project);
   }
 
-  private final ConcurrentMap<PsiExpression, PsiType> myCalculatedTypes = new ConcurrentWeakHashMap<PsiExpression, PsiType>();
-  private final ConcurrentMap<PsiElement, PsiType> myCachedReferencesInPsiTypes = new ConcurrentWeakHashMap<PsiElement, PsiType>();
-  // e.g. given FileOutputStream os, os2;
-  // PsiJavaCodeReferenceElement("FileOutputStream") -> [ PsiReferenceExpression("os"), PsiReferenceExpression("os2") ]
-  private final Map<PsiElement, WeakList<PsiElement>> myCachedReferenceIn_PsiClassReferenceType_To_ListOfReferencesOfThisType_CachedHere  = new WeakHashMap<PsiElement, WeakList<PsiElement>>();
+  private final ConcurrentMap<PsiExpression, Reference<PsiType>> myCalculatedTypes = new ConcurrentWeakHashMap<PsiExpression, Reference<PsiType>>();
 
   private final Map<PsiVariable,Object> myVarToConstValueMapPhysical;
   private final Map<PsiVariable,Object> myVarToConstValueMapNonPhysical;
@@ -86,39 +79,31 @@ public class JavaResolveCache {
 
   private void clearCaches(boolean isPhysical) {
     myCalculatedTypes.clear();
-    myCachedReferencesInPsiTypes.clear();
-    myCachedReferenceIn_PsiClassReferenceType_To_ListOfReferencesOfThisType_CachedHere.clear();
     if (isPhysical) {
       myVarToConstValueMapPhysical.clear();
     }
     myVarToConstValueMapNonPhysical.clear();
   }
 
-  public boolean isTypeCached(@NotNull PsiExpression expr) {
-    return myCalculatedTypes.get(expr) != null;
-  }
-
   @Nullable
   public <T extends PsiExpression> PsiType getType(@NotNull T expr, @NotNull Function<T, PsiType> f) {
-    PsiType type = myCalculatedTypes.get(expr);
+    PsiType type = getCachedType(expr);
     if (type == null) {
       type = f.fun(expr);
       if (type == null) {
         type = TypeConversionUtil.NULL_TYPE;
       }
-      PsiType stored = ConcurrencyUtil.cacheOrGet(myCalculatedTypes, expr, type);
+      SoftReference<PsiType> ref = new SoftReference<PsiType>(type);
+      Reference<PsiType> storedRef = ConcurrencyUtil.cacheOrGet(myCalculatedTypes, expr, ref);
 
-      if (stored == type && DebugUtil.DO_EXPENSIVE_CHECKS) {
-        registerDiagnosticsHooks(expr, type);
-      }
-
-      type = stored;
+      PsiType stored = storedRef.get();
+      type = stored == null ? type : stored;
     }
 
     if (!type.isValid()) {
       if (expr.isValid()) {
         PsiJavaCodeReferenceElement refInside = type instanceof PsiClassReferenceType ? ((PsiClassReferenceType)type).getReference() : null;
-        String typeinfo = type + " (" + type.getClass() + ")" + (refInside == null ? "" : "; ref inside: "+refInside + " ("+refInside.getClass()+") valid:"+refInside.isValid());
+        @NonNls String typeinfo = type + " (" + type.getClass() + ")" + (refInside == null ? "" : "; ref inside: "+refInside + " ("+refInside.getClass()+") valid:"+refInside.isValid());
         LOG.error("Type is invalid: " + typeinfo + "; expr: '" + expr + "' (" + expr.getClass() + ") is valid");
       }
       else {
@@ -129,83 +114,9 @@ public class JavaResolveCache {
     return type == TypeConversionUtil.NULL_TYPE ? null : type;
   }
 
-  private <T extends PsiExpression> void registerDiagnosticsHooks(T expr, PsiType type) {
-    if (type instanceof PsiClassReferenceType) {
-      PsiJavaCodeReferenceElement reference = ((PsiClassReferenceType)type).getReference();
-      ConcurrencyUtil.cacheOrGet(myCachedReferencesInPsiTypes, reference, type);
-      synchronized (myCachedReferenceIn_PsiClassReferenceType_To_ListOfReferencesOfThisType_CachedHere) {
-        WeakList<PsiElement> refsTo = myCachedReferenceIn_PsiClassReferenceType_To_ListOfReferencesOfThisType_CachedHere.get(reference);
-        if (refsTo==null) {
-          refsTo = new WeakList<PsiElement>();
-          myCachedReferenceIn_PsiClassReferenceType_To_ListOfReferencesOfThisType_CachedHere.put(reference, refsTo);
-        }
-        refsTo.add(expr);
-      }
-      final PsiFile dummyHolder = reference.getContainingFile();
-      if (dummyHolder != null && !dummyHolder.isPhysical()) {
-        PsiElement physicalContext = dummyHolder.getContext();
-        PsiFile physicalFile;
-        if (physicalContext != null &&
-            (physicalFile = physicalContext.getContainingFile()) != null &&
-            physicalFile.getVirtualFile() != null &&
-            !((PsiManagerEx)dummyHolder.getManager()).isAssertOnFileLoading(physicalFile.getVirtualFile())) {
-          DebugUtil.trackInvalidation(physicalContext, "dummy holder was invalidated", new Processor<PsiElement>() {
-            @Override
-            public boolean process(PsiElement element) {
-              DebugUtil.onInvalidated((TreeElement)dummyHolder.getNode());
-              return true;
-            }
-          });
-        }
-      }
-
-      DebugUtil.trackInvalidation(reference, "Reference inside PsiClassReferenceType was invalidated", new Processor<PsiElement>() {
-        @Override
-        public boolean process(PsiElement element) {
-          PsiType cached = myCalculatedTypes.get(element);
-          if (cached != null) {
-            LOG.error(element + " (inside ref) is invalid and yet it is still cached: " + cached);
-          }
-          PsiType cachedRef = myCachedReferencesInPsiTypes.get(element);
-          if (cachedRef != null) {
-            LOG.error(element + " (inside ref) is invalid and yet it is still cached in ref cache: " + cachedRef);
-          }
-
-
-          synchronized (myCachedReferenceIn_PsiClassReferenceType_To_ListOfReferencesOfThisType_CachedHere) {
-            WeakList<PsiElement> refsTo = myCachedReferenceIn_PsiClassReferenceType_To_ListOfReferencesOfThisType_CachedHere.get(element);
-            if (refsTo != null) {
-              for (PsiElement ref : refsTo) {
-                PsiType cachedT = myCalculatedTypes.get(ref);
-                if (cachedT != null && !cachedT.isValid()) {
-                  LOG.error("During invalidation of " + element + " ("+element.getClass()+")"+
-                            " cached type " + cachedT + " of the ref "+ref+" ("+ref.getClass()+")"+
-                            " became invalid and yet it is still cached"
-                  );
-                }
-              }
-            }
-          }
-
-          return true;
-        }
-      });
-    }
-    DebugUtil.trackInvalidation(expr, "Expression invalidated", new Processor<PsiElement>() {
-      @Override
-      public boolean process(PsiElement element) {
-        PsiType cached = myCalculatedTypes.get(element);
-        if (cached != null) {
-          LOG.error(element + " is invalid and yet it is still cached: " + cached);
-        }
-
-        PsiType cachedRef = myCachedReferencesInPsiTypes.get(element);
-        if (cachedRef != null) {
-          LOG.error(element + " is invalid and yet it is still cached (inside PsiType): " + cachedRef);
-        }
-        return true;
-      }
-    });
+  private <T extends PsiExpression> PsiType getCachedType(T expr) {
+    Reference<PsiType> reference = myCalculatedTypes.get(expr);
+    return reference == null ? null : reference.get();
   }
 
   @Nullable

java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaElementType.java

@@ -41,8 +41,7 @@ public interface JavaElementType {
     private final Constructor<? extends ASTNode> myConstructor;
 
     private JavaCompositeElementType(@NonNls final String debugName, final Class<? extends ASTNode> nodeClass) {
-      super(debugName);
-      myConstructor = ReflectionUtil.getDefaultConstructor(nodeClass);
+      this(debugName, nodeClass, false);
     }
 
     private JavaCompositeElementType(@NonNls final String debugName, final Class<? extends ASTNode> nodeClass, final boolean leftBound) {

java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiBinaryExpressionImpl.java

@@ -17,7 +17,6 @@ package com.intellij.psi.impl.source.tree.java;
 
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.progress.ProgressIndicatorProvider;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.source.resolve.JavaResolveCache;
 import com.intellij.psi.impl.source.tree.ChildRole;
@@ -33,6 +32,8 @@ import org.jetbrains.annotations.NotNull;
 public class PsiBinaryExpressionImpl extends ExpressionPsiElement implements PsiBinaryExpression {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.java.PsiBinaryExpressionImpl");
 
+  /** used via reflection in {@link com.intellij.psi.impl.source.tree.JavaElementType.JavaCompositeElementType#JavaCompositeElementType(java.lang.String, java.lang.Class)} */
+  @SuppressWarnings("UnusedDeclaration")
   public PsiBinaryExpressionImpl() {
     this(JavaElementType.BINARY_EXPRESSION);
   }
@@ -79,24 +80,6 @@ public class PsiBinaryExpressionImpl extends ExpressionPsiElement implements Psi
     PsiType type = TypeConversionUtil.calcTypeForBinaryExpression(null, rType, sign, false);
     if (type != TypeConversionUtil.NULL_TYPE) return type;
 
-    if (lOperand instanceof PsiBinaryExpressionImpl && !JavaResolveCache.getInstance(param.getProject()).isTypeCached(lOperand)) {
-      // cache all intermediate expression types from bottom up
-      PsiBinaryExpressionImpl topLevel = param;
-      PsiElement element = param;
-      while (element instanceof PsiBinaryExpressionImpl) {
-        topLevel = (PsiBinaryExpressionImpl)element;
-        element = element.getParent();
-      }
-      topLevel.accept(new JavaRecursiveElementWalkingVisitor() {
-        @Override
-        protected void elementFinished(PsiElement element) {
-          if (element instanceof PsiExpression) {
-            ProgressIndicatorProvider.checkCanceled();
-            ((PsiExpression)element).getType();
-          }
-        }
-      });
-    }
     PsiType lType = lOperand.getType();
     return TypeConversionUtil.calcTypeForBinaryExpression(lType, rType, sign, true);
   }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/afterJavadoc.java

@@ -0,0 +1,14 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+    /**  
+   */
+  void foo() {
+      foo();
+  }
+
+    /**
+   * @param i
+   */
+  void foo(int ii){
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/beforeJavadoc.java

@@ -0,0 +1,8 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+  /**
+   * @param i
+   */
+  void foo(int i<caret>i){
+  }
+}

java/java-tests/testData/refactoring/changeClassSignature/InstanceOf.java

@@ -0,0 +1,11 @@
+public class ChangeClassSignatureAddParameter {
+
+  public void test(Object object) {
+    if (object instanceof MyClass) {
+      MyClass myClass = (MyClass)object;
+    }
+  }
+}
+
+class My<caret>Class {
+}

java/java-tests/testData/refactoring/changeClassSignature/InstanceOf.java.after

@@ -0,0 +1,11 @@
+public class ChangeClassSignatureAddParameter {
+
+  public void test(Object object) {
+    if (object instanceof MyClass) {
+      MyClass<String> myClass = (MyClass<String>)object;
+    }
+  }
+}
+
+class MyClass<T> {
+}

java/java-tests/testData/refactoring/introduceField/afterStaticFieldInInnerClass.java

@@ -0,0 +1,9 @@
+public class A {
+  private static final class Inner {
+      public final String string;
+
+      public Inner(Integer param) {
+          string = param.toString();
+     }
+  }
+}

java/java-tests/testData/refactoring/introduceField/beforeStaticFieldInInnerClass.java

@@ -0,0 +1,7 @@
+public class A {
+  private static final class Inner {
+     public Inner(Integer param) {
+        String s<caret>tr = param.toString();
+     }
+  }
+}

java/java-tests/testData/refactoring/migration/packageToNonExistentPackage/after/p1/C1.java

@@ -1,5 +1,7 @@
 package p1;
 
+import zzz.bbb.*;
+
 class C {
   zzz.bbb.AAA a = new zzz.bbb.AAA();
 }

java/java-tests/testSrc/com/intellij/codeInsight/AddAnnotationFixTest.java

@@ -45,7 +45,7 @@ public class AddAnnotationFixTest extends UsefulTestCase {
   @Override
   public void setUp() throws Exception {
     super.setUp();
-    final TestFixtureBuilder<IdeaProjectTestFixture> projectBuilder = IdeaTestFixtureFactory.getFixtureFactory().createFixtureBuilder();
+    final TestFixtureBuilder<IdeaProjectTestFixture> projectBuilder = IdeaTestFixtureFactory.getFixtureFactory().createFixtureBuilder(getName());
 
     myFixture = JavaTestFixtureFactory.getFixtureFactory().createCodeInsightFixture(projectBuilder.getFixture());
     final String dataPath = PathManagerEx.getTestDataPath() + "/codeInsight/externalAnnotations";

java/java-tests/testSrc/com/intellij/psi/AstLeaksTest.groovy

@@ -22,6 +22,7 @@ import com.intellij.psi.impl.source.tree.java.MethodElement
 import com.intellij.testFramework.LeakHunter
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import com.intellij.util.Processor
+import com.intellij.codeInspection.defaultFileTemplateUsage.DefaultFileTemplateUsageInspection
 
 /**
  * @author peter
@@ -74,4 +75,14 @@ class AstLeaksTest extends LightCodeInsightFixtureTestCase {
     LeakHunter.checkLeak(sup, MethodElement)
   }
 
+  public void "test no hard refs to Default File Template inspection internal AST"() {
+    myFixture.addFileToProject('sup.java', 'class Super { void bar() {} }')
+    PsiJavaFile foo = myFixture.addFileToProject('a.java', 'class Foo { void bar() { bar(); } }')
+    myFixture.configureFromExistingVirtualFile(foo.virtualFile)
+    myFixture.enableInspections(new DefaultFileTemplateUsageInspection())
+    myFixture.doHighlighting()
+
+    LeakHunter.checkLeak(foo.classes[0], MethodElement, { MethodElement node -> !node.psi.physical } as Processor<MethodElement>)
+  }
+
 }

java/java-tests/testSrc/com/intellij/psi/StubAstSwitchTest.groovy

@@ -35,11 +35,11 @@ class StubAstSwitchTest extends LightCodeInsightFixtureTestCase {
     def oldCount = psiManager.modificationTracker.javaStructureModificationCount
 
     ApplicationManager.application.runWriteAction { file.virtualFile.setBinaryContent(file.virtualFile.contentsToByteArray()) }
-    assert file.stub
 
     assert psiManager.modificationTracker.javaStructureModificationCount != oldCount
 
     assert !cls.valid
+    assert file.stub
     assert cls != PsiTreeUtil.findElementOfClassAtOffset(file, 1, PsiClass, false)
     assert !file.stub
   }

java/java-tests/testSrc/com/intellij/psi/impl/file/impl/EventsTestListener.java

@@ -2,6 +2,7 @@ package com.intellij.psi.impl.file.impl;
 
 import com.intellij.psi.PsiTreeChangeEvent;
 import com.intellij.psi.PsiTreeChangeListener;
+import org.jetbrains.annotations.NotNull;
 
 /**
  *  @author dsl
@@ -14,62 +15,62 @@ class EventsTestListener implements PsiTreeChangeListener {
   }
 
   @Override
-  public void beforeChildAddition(PsiTreeChangeEvent event) {
+  public void beforeChildAddition(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("beforeChildAddition\n");
   }
 
   @Override
-  public void beforeChildRemoval(PsiTreeChangeEvent event) {
+  public void beforeChildRemoval(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("beforeChildRemoval\n");
   }
 
   @Override
-  public void beforeChildReplacement(PsiTreeChangeEvent event) {
+  public void beforeChildReplacement(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("beforeChildReplacement\n");
   }
 
   @Override
-  public void beforeChildMovement(PsiTreeChangeEvent event) {
+  public void beforeChildMovement(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("beforeChildMovement\n");
   }
 
   @Override
-  public void beforeChildrenChange(PsiTreeChangeEvent event) {
+  public void beforeChildrenChange(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("beforeChildrenChange\n");
   }
 
   @Override
-  public void beforePropertyChange(PsiTreeChangeEvent event) {
+  public void beforePropertyChange(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("beforePropertyChange\n");
   }
 
   @Override
-  public void childAdded(PsiTreeChangeEvent event) {
+  public void childAdded(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("childAdded\n");
   }
 
   @Override
-  public void childRemoved(PsiTreeChangeEvent event) {
+  public void childRemoved(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("childRemoved\n");
   }
 
   @Override
-  public void childReplaced(PsiTreeChangeEvent event) {
+  public void childReplaced(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("childReplaced\n");
   }
 
   @Override
-  public void childrenChanged(PsiTreeChangeEvent event) {
+  public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("childrenChanged\n");
   }
 
   @Override
-  public void childMoved(PsiTreeChangeEvent event) {
+  public void childMoved(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("childMoved\n");
   }
 
   @Override
-  public void propertyChanged(PsiTreeChangeEvent event) {
+  public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
     myBuffer.append("propertyChanged\n");
   }
 }

java/java-tests/testSrc/com/intellij/psi/impl/file/impl/InvalidateClassFileTest.java

@@ -31,6 +31,7 @@ import com.intellij.psi.PsiTreeChangeAdapter;
 import com.intellij.psi.PsiTreeChangeEvent;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.testFramework.PsiTestCase;
+import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
 
@@ -78,12 +79,12 @@ public class InvalidateClassFileTest extends PsiTestCase {
     final boolean[] notified = new boolean[] {false};
     final PsiTreeChangeAdapter listener = new PsiTreeChangeAdapter() {
       @Override
-      public void childRemoved(PsiTreeChangeEvent event) {
+      public void childRemoved(@NotNull PsiTreeChangeEvent event) {
         notified[0] = true;
       }
 
       @Override
-      public void childrenChanged(PsiTreeChangeEvent event) {
+      public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
         notified[0] = true;
       }
     };

java/java-tests/testSrc/com/intellij/psi/impl/file/impl/PsiEventsTest.java

@@ -21,6 +21,7 @@ import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.testFramework.PsiTestCase;
 import com.intellij.util.io.ReadOnlyAttributeUtil;
 import com.intellij.util.WaitFor;
+import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
 import java.io.IOException;
@@ -529,7 +530,7 @@ public class PsiEventsTest extends PsiTestCase {
     final VirtualFile virtualFile = createFile("a.xml", "<tag/>").getVirtualFile();
     final PsiTreeChangeAdapter listener = new PsiTreeChangeAdapter() {
       @Override
-      public void propertyChanged(PsiTreeChangeEvent event) {
+      public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
         getJavaFacade().findClass("XXX", GlobalSearchScope.allScope(myProject));
       }
     };
@@ -544,67 +545,67 @@ public class PsiEventsTest extends PsiTestCase {
   public void testBeforeAfterChildrenChange() throws Throwable {
     listener = new PsiTreeChangeListener() {
       @Override
-      public void beforeChildAddition(PsiTreeChangeEvent event) {
+      public void beforeChildAddition(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
       }
 
       @Override
-      public void beforeChildRemoval(PsiTreeChangeEvent event) {
+      public void beforeChildRemoval(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
       }
 
       @Override
-      public void beforeChildReplacement(PsiTreeChangeEvent event) {
+      public void beforeChildReplacement(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
       }
 
       @Override
-      public void beforeChildMovement(PsiTreeChangeEvent event) {
+      public void beforeChildMovement(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
       }
 
       @Override
-      public void beforeChildrenChange(PsiTreeChangeEvent event) {
+      public void beforeChildrenChange(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
       }
 
       @Override
-      public void beforePropertyChange(PsiTreeChangeEvent event) {
+      public void beforePropertyChange(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
       }
 
       @Override
-      public void childAdded(PsiTreeChangeEvent event) {
+      public void childAdded(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
         assertBeforeEventFired(event);
       }
 
       @Override
-      public void childRemoved(PsiTreeChangeEvent event) {
+      public void childRemoved(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
         assertBeforeEventFired(event);
       }
 
       @Override
-      public void childReplaced(PsiTreeChangeEvent event) {
+      public void childReplaced(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
         assertBeforeEventFired(event);
       }
 
       @Override
-      public void childrenChanged(PsiTreeChangeEvent event) {
+      public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
         assertBeforeEventFired(event);
       }
 
       @Override
-      public void childMoved(PsiTreeChangeEvent event) {
+      public void childMoved(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
         assertBeforeEventFired(event);
       }
 
       @Override
-      public void propertyChanged(PsiTreeChangeEvent event) {
+      public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
         logEvent(event);
         assertBeforeEventFired(event);
       }

java/java-tests/testSrc/com/intellij/refactoring/IntroduceFieldInSameClassTest.java

@@ -1,12 +1,15 @@
 package com.intellij.refactoring;
 
 import com.intellij.JavaTestUtil;
+import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiPrimitiveType;
 import com.intellij.psi.PsiType;
 import com.intellij.refactoring.introduceField.BaseExpressionToFieldHandler;
 import com.intellij.refactoring.util.CommonRefactoringUtil;
 import com.intellij.testFramework.LightCodeInsightTestCase;
 
+import java.util.List;
+
 /**
  * @author ven
  */
@@ -115,4 +118,16 @@ public class IntroduceFieldInSameClassTest extends LightCodeInsightTestCase {
     performRefactoring(BaseExpressionToFieldHandler.InitializationPlace.IN_FIELD_DECLARATION, false);
     checkResultByFile("/refactoring/introduceField/afterLocalVarAnnotations.java");
   }
+  
+  public void testStaticFieldInInnerClass() throws Exception {
+    configureByFile("/refactoring/introduceField/beforeStaticFieldInInnerClass.java");
+    new MockIntroduceFieldHandler(BaseExpressionToFieldHandler.InitializationPlace.IN_CURRENT_METHOD, false){
+      @Override
+      protected int getChosenClassIndex(List<PsiClass> classes) {
+        return 0;
+      }
+    }.invoke(getProject(), myEditor, myFile, null);
+    checkResultByFile("/refactoring/introduceField/afterStaticFieldInInnerClass.java");
+  }
+  
 }

java/java-tests/testSrc/com/intellij/refactoring/changeClassSignature/ChangeClassSignatureTest.java

@@ -30,6 +30,17 @@ public class ChangeClassSignatureTest extends LightRefactoringTestCase {
     });
   }
 
+  public void testInstanceOf() throws Exception {
+    doTest(new GenParams() {
+      @Override
+      public TypeParameterInfo[] gen(PsiClass aClass) throws IncorrectOperationException {
+        return new TypeParameterInfo[]{
+          new TypeParameterInfo(aClass, "T", "java.lang.String")
+        };
+      }
+    });
+  }
+
   public void testSubstituteParamInsideClass() throws Exception {
     doTest(new GenParams() {
       @Override

java/openapi/src/com/intellij/execution/filters/ExceptionWorker.java

@@ -30,6 +30,7 @@ import com.intellij.psi.PsiManager;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.PsiShortNamesCache;
 import com.intellij.util.ui.UIUtil;
+import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.Nullable;
 
 import java.awt.*;
@@ -40,6 +41,9 @@ import java.awt.*;
  * Time: 8:36 PM
  */
 public class ExceptionWorker {
+  @NonNls private static final String AT = "at";
+  private static final String AT_PREFIX = AT + " ";
+  private static final String STANDALONE_AT = " " + AT + " ";
 
   private static final TextAttributes HYPERLINK_ATTRIBUTES = EditorColorsManager
     .getInstance().getGlobalScheme().getAttributes(CodeInsightColors.HYPERLINK_ATTRIBUTES);
@@ -73,12 +77,12 @@ public class ExceptionWorker {
 
     final int lparenthIndex = myInfo.third.getStartOffset();
     final int rparenthIndex = myInfo.third.getEndOffset();
-    final String fileAndLine = line.substring(lparenthIndex + 1, rparenthIndex);
+    final String fileAndLine = line.substring(lparenthIndex + 1, rparenthIndex).trim();
 
     final int colonIndex = fileAndLine.lastIndexOf(':');
-    if (colonIndex <= 0) return;
+    if (colonIndex < 0) return;
 
-    final String lineString = fileAndLine.substring(colonIndex + 1).trim();
+    final String lineString = fileAndLine.substring(colonIndex + 1);
     try {
       final int lineNumber = Integer.parseInt(lineString);
       final PsiManager manager = PsiManager.getInstance(myProject);
@@ -142,18 +146,34 @@ public class ExceptionWorker {
     return myInfo;
   }
 
+  //todo [roma] regexp
   @Nullable
   static Trinity<TextRange, TextRange, TextRange> parseExceptionLine(final String line) {
-    int lparenIdx = line.indexOf('(');
-    int rparenIdx = line.indexOf(')', lparenIdx + 1);
-    if (lparenIdx < 0 || rparenIdx <= lparenIdx) return null;
+    int startIdx;
+    if (line.startsWith(AT_PREFIX)){
+      startIdx = 0;
+    }
+    else{
+      startIdx = line.indexOf(STANDALONE_AT);
+      if (startIdx < 0) {
+        startIdx = line.indexOf(AT_PREFIX);
+      }
 
-    int dotIdx = line.lastIndexOf('.', lparenIdx);
-    int startIdx = handleSpaces(line, dotIdx, -1, false);
-    if (startIdx == dotIdx) return null;
+      if (startIdx < 0) {
+        startIdx = -1;
+      }
+    }
+
+    final int lparenIdx = line.indexOf('(', startIdx);
+    if (lparenIdx < 0) return null;
+    final int dotIdx = line.lastIndexOf('.', lparenIdx);
+    if (dotIdx < 0 || dotIdx < startIdx) return null;
+
+    final int rparenIdx = line.indexOf(')', lparenIdx);
+    if (rparenIdx < 0) return null;
 
     // class, method, link
-    return Trinity.create(new TextRange(startIdx + 1, handleSpaces(line, dotIdx, -1, true)),
+    return Trinity.create(new TextRange(startIdx + 1 + (startIdx >= 0 ? AT.length() : 0), handleSpaces(line, dotIdx, -1, true)),
                           new TextRange(handleSpaces(line, dotIdx + 1, 1, true), handleSpaces(line, lparenIdx + 1, -1, true)),
                           new TextRange(lparenIdx, rparenIdx));
   }

jps/jps-builders/src/org/jetbrains/jps/incremental/IncProjectBuilder.java

@@ -87,7 +87,15 @@ public class IncProjectBuilder {
     CompileContext context = null;
     try {
       try {
-        context = createContext(scope, isMake, isProjectRebuild);
+        if (myProjectDescriptor.dataManager.versionDiffers()) {
+          myMessageDispatcher.processMessage(new CompilerMessage(
+            COMPILE_SERVER_NAME, BuildMessage.Kind.INFO, "Dependency data format has changed, project rebuild required"
+          ));
+          context = createContextForForcedRebuild(scope, isMake, isProjectRebuild);
+        }
+        else {
+          context = createContext(scope, isMake, isProjectRebuild);
+        }
         runBuild(context);
       }
       catch (ProjectBuildException e) {
@@ -100,20 +108,14 @@ public class IncProjectBuilder {
             e.getMessage())
           );
           flushContext(context);
-          if (isMake || isProjectRebuild) {
-            context = createContext(new AllProjectScope(scope.getProject(), scope.getArtifacts(), true), false, true);
-          }
-          else {
-            //in case of forced compilation keep the scope, but remove all caches
-            context = createContext(scope, false, false);
-            cleanOutputRoots(context);
-          }
+          context = createContextForForcedRebuild(scope, isMake, isProjectRebuild);
           runBuild(context);
         }
         else {
           throw e;
         }
       }
+      myProjectDescriptor.dataManager.saveVersion();
     }
     catch (ProjectBuildException e) {
       final Throwable cause = e.getCause();
@@ -133,6 +135,19 @@ public class IncProjectBuilder {
     }
   }
 
+  private CompileContext createContextForForcedRebuild(CompileScope scope, boolean isMake, boolean isProjectRebuild) throws ProjectBuildException {
+    final CompileContext context;
+    if (isMake || isProjectRebuild) {
+      context = createContext(new AllProjectScope(scope.getProject(), scope.getArtifacts(), true), false, true);
+    }
+    else {
+      //in case of forced compilation keep the scope, but remove all caches
+      context = createContext(scope, false, false);
+      cleanOutputRoots(context);
+    }
+    return context;
+  }
+
   private static void flushContext(CompileContext context) {
     if (context != null) {
       context.getTimestampStorage().force();

jps/jps-builders/src/org/jetbrains/jps/incremental/storage/BuildDataManager.java

@@ -8,8 +8,7 @@ import org.jetbrains.jps.Module;
 import org.jetbrains.jps.ModuleChunk;
 import org.jetbrains.jps.incremental.artifacts.ArtifactsBuildData;
 
-import java.io.File;
-import java.io.IOException;
+import java.io.*;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
@@ -19,6 +18,7 @@ import java.util.Map;
  *         Date: 10/7/11
  */
 public class BuildDataManager {
+  private static final int VERSION = 1;
   private static final Logger LOG = Logger.getInstance("#org.jetbrains.jps.incremental.storage.BuildDataManager");
   private static final String SRC_TO_OUTPUTS_STORAGE = "src-out";
   private static final String SRC_TO_FORM_STORAGE = "src-form";
@@ -32,12 +32,14 @@ public class BuildDataManager {
   private final ArtifactsBuildData myArtifactsBuildData;
   private final Mappings myMappings;
   private final File myDataStorageRoot;
+  private final File myVersionFile;
 
   public BuildDataManager(final File dataStorageRoot, final boolean useMemoryTempCaches) throws IOException {
     myDataStorageRoot = dataStorageRoot;
     mySrcToFormMap = new SourceToFormMapping(new File(getSourceToFormsRoot(), "data"));
     myMappings = new Mappings(getMappingsRoot(), useMemoryTempCaches);
     myArtifactsBuildData = new ArtifactsBuildData(new File(dataStorageRoot, "artifacts"));
+    myVersionFile = new File(myDataStorageRoot, "version.dat");
   }
 
   public SourceToOutputMapping getSourceToOutputMap(String moduleName, boolean testSources) throws IOException {
@@ -237,4 +239,50 @@ public class BuildDataManager {
       }
     }
   }
+
+  private Boolean myVersionDiffers = null;
+
+  public boolean versionDiffers() {
+    final Boolean cached = myVersionDiffers;
+    if (cached != null) {
+      return cached;
+    }
+    try {
+      final DataInputStream is = new DataInputStream(new FileInputStream(myVersionFile));
+      try {
+        final boolean diff = is.readInt() != VERSION;
+        myVersionDiffers = diff;
+        return diff;
+      }
+      finally {
+        is.close();
+      }
+    }
+    catch (FileNotFoundException ignored) {
+      return false; // treat it as a new dir
+    }
+    catch (IOException ex) {
+      LOG.info(ex);
+    }
+    return true;
+  }
+
+  public void saveVersion() {
+    final Boolean differs = myVersionDiffers;
+    if (differs == null || differs) {
+      try {
+        FileUtil.createIfDoesntExist(myVersionFile);
+        final DataOutputStream os = new DataOutputStream(new FileOutputStream(myVersionFile));
+        try {
+          os.writeInt(VERSION);
+          myVersionDiffers = Boolean.FALSE;
+        }
+        finally {
+          os.close();
+        }
+      }
+      catch (IOException ignored) {
+      }
+    }
+  }
 }

jps/jps-builders/src/org/jetbrains/jps/server/ClasspathBootstrap.java

@@ -15,29 +15,24 @@
  */
 package org.jetbrains.jps.server;
 
-import com.google.common.cache.CacheBuilder;
+import com.google.protobuf.Message;
 import com.intellij.compiler.notNullVerification.NotNullVerifyingInstrumenter;
 import com.intellij.openapi.application.PathManager;
-import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.uiDesigner.compiler.AlienFormFileException;
 import com.intellij.uiDesigner.core.GridConstraints;
 import com.jgoodies.forms.layout.CellConstraints;
-import com.sun.jna.Pointer;
-import gnu.trove.TIntHash;
 import net.n3.nanoxml.IXMLBuilder;
 import org.codehaus.groovy.GroovyException;
+import org.jboss.netty.util.Version;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.MacroExpander;
 import org.jetbrains.jps.javac.JavacServer;
-import com.intellij.openapi.util.io.FileUtilRt;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.EmptyVisitor;
 
 import javax.tools.*;
 import java.io.File;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 /**
  * @author Eugene Zhuravlev
@@ -88,24 +83,18 @@ public class ClasspathBootstrap {
   public static List<File> getCompileServerApplicationClasspath() {
     final Set<File> cp = new LinkedHashSet<File>();
     cp.add(getResourcePath(Server.class));
-    cp.add(getResourcePath(com.google.protobuf.Message.class)); // protobuf
-    cp.add(getResourcePath(org.jboss.netty.bootstrap.Bootstrap.class)); // netty
-    cp.add(getResourcePath(TIntHash.class));  // trove
-    cp.add(getResourcePath(FileUtilRt.class));  // util-rt module
-    cp.add(getResourcePath(FileUtil.class));  // util module
-    cp.add(getResourcePath(Pointer.class));  // jna.jar
-    cp.add(getResourcePath(CacheBuilder.class));  // guava
+    for (String path : PathManager.getUtilClassPath()) { cp.add(new File(path)); } // util
+    cp.add(getResourcePath(Message.class)); // protobuf
+    cp.add(getResourcePath(Version.class)); // netty
     cp.add(getResourcePath(ClassWriter.class));  // asm
-    cp.add(getResourcePath(org.objectweb.asm.commons.EmptyVisitor.class));  // asm-commons
+    cp.add(getResourcePath(EmptyVisitor.class));  // asm-commons
     cp.add(getResourcePath(MacroExpander.class));  // jps-model
     cp.add(getResourcePath(AlienFormFileException.class));  // forms-compiler
     cp.add(getResourcePath(GroovyException.class));  // groovy
-    cp.add(getResourcePath(org.jdom.input.SAXBuilder.class));  // jdom
     cp.add(getResourcePath(GridConstraints.class));  // forms-rt
     cp.add(getResourcePath(CellConstraints.class));  // jgoodies-forms
     cp.add(getResourcePath(NotNullVerifyingInstrumenter.class));  // not-null
     cp.add(getResourcePath(IXMLBuilder.class));  // nano-xml
-    cp.add(getResourcePath(org.apache.log4j.Logger.class)); // log4j
 
     final Class<StandardJavaFileManager> optimizedFileManagerClass = getOptimizedFileManagerClass();
     if (optimizedFileManagerClass != null) {
@@ -133,14 +122,9 @@ public class ClasspathBootstrap {
   public static List<File> getJavacServerClasspath() {
     final Set<File> cp = new LinkedHashSet<File>();
     cp.add(getResourcePath(JavacServer.class));
-    cp.add(getResourcePath(com.google.protobuf.Message.class)); // protobuf
-    cp.add(getResourcePath(org.jboss.netty.bootstrap.Bootstrap.class)); // netty
-    cp.add(getResourcePath(TIntHash.class));  // trove
-    cp.add(getResourcePath(FileUtilRt.class));  // util-rt module
-    cp.add(getResourcePath(FileUtil.class));  // util module
-    cp.add(getResourcePath(Pointer.class));  // jna.jar
-    cp.add(getResourcePath(CacheBuilder.class));  // guava
-    cp.add(getResourcePath(org.jdom.input.SAXBuilder.class));  // jdom
+    for (String path : PathManager.getUtilClassPath()) { cp.add(new File(path)); } // util
+    cp.add(getResourcePath(Message.class)); // protobuf
+    cp.add(getResourcePath(Version.class)); // netty
 
     final Class<StandardJavaFileManager> optimizedFileManagerClass = getOptimizedFileManagerClass();
     if (optimizedFileManagerClass != null) {
@@ -178,5 +162,4 @@ public class ClasspathBootstrap {
   public static File getResourcePath(Class aClass) {
     return new File(PathManager.getResourceRoot(aClass, "/" + aClass.getName().replace('.', '/') + ".class"));
   }
-
 }

jps/jps-builders/src/org/jetbrains/jps/server/Server.java

@@ -130,12 +130,15 @@ public class Server {
       }
 
       private void doStop(long elapsedTime) {
-        try {
-          System.out.println("Stopping compile server; reason: no pings from client received in " + elapsedTime + " ms");
-          myMessageHandler.cancelAllBuildsAndClearState();
-        }
-        finally {
-          stop();
+        if (!myMessageHandler.hasRunningBuilds()) {
+          try {
+            System.out.println("Stopping compile server; reason: no pings from client received in " + elapsedTime + " ms");
+            myMessageHandler.cancelAllBuildsAndClearState();
+            stop();
+          }
+          finally {
+            System.exit(0);
+          }
         }
       }
     }, allowedIdlePeriod, allowedIdlePeriod, TimeUnit.MILLISECONDS);

jps/model/src/org/jetbrains/ether/dependencyView/Mappings.java

@@ -1070,10 +1070,12 @@ public class Mappings {
 
                 }
                 else {
+                  final Option<Boolean> inheritorOf = self.isInheritorOf(cc.name, it.name);
+
                   debug("Method: ", mm.name);
                   debug("Class : ", cc.name);
 
-                  if (overrides.satisfy(mm)) {
+                  if (overrides.satisfy(mm) && inheritorOf.isValue() && inheritorOf.value()) {
                     debug("Current method overrides that found");
 
                     final Option<Boolean> subtypeOf = u.isSubtypeOf(mm.type, m.type);
@@ -1099,8 +1101,6 @@ public class Mappings {
 
                     final Collection<DependencyContext.S> yetPropagated = self.propagateMethodAccess(mm.name, it.name);
 
-                    final Option<Boolean> inheritorOf = self.isInheritorOf(cc.name, it.name);
-
                     if (inheritorOf.isValue() && inheritorOf.value()) {
                       final Collection<DependencyContext.S> deps = myClassToClassDependency.get(cc.name);
 

platform/core-api/src/com/intellij/psi/PsiTreeChangeListener.java

@@ -15,6 +15,8 @@
  */
 package com.intellij.psi;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.util.EventListener;
 
 /**
@@ -31,7 +33,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void beforeChildAddition(PsiTreeChangeEvent event);
+  void beforeChildAddition(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just before removal of a child from the tree.<br>
@@ -40,7 +42,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void beforeChildRemoval(PsiTreeChangeEvent event);
+  void beforeChildRemoval(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just before replacement of a child in the tree by another element.<br>
@@ -49,7 +51,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void beforeChildReplacement(PsiTreeChangeEvent event);
+  void beforeChildReplacement(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just before movement of a child in the tree by changing its parent or by changing its position in the same parent.<br>
@@ -59,7 +61,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void beforeChildMovement(PsiTreeChangeEvent event);
+  void beforeChildMovement(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked before a mass change of children of the specified node.<br>
@@ -67,7 +69,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void beforeChildrenChange(PsiTreeChangeEvent event);
+  void beforeChildrenChange(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just before changing of some property of an element.<br>
@@ -77,7 +79,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void beforePropertyChange(PsiTreeChangeEvent event);
+  void beforePropertyChange(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just after adding of a new child to the tree.<br>
@@ -86,7 +88,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void childAdded(PsiTreeChangeEvent event);
+  void childAdded(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just after removal of a child from the tree.<br>
@@ -97,7 +99,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void childRemoved(PsiTreeChangeEvent event);
+  void childRemoved(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just after replacement of a child in the tree by another element.<br>
@@ -109,7 +111,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void childReplaced(PsiTreeChangeEvent event);
+  void childReplaced(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked after a mass change of children of the specified node.<br>
@@ -117,7 +119,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void childrenChanged(PsiTreeChangeEvent event);
+  void childrenChanged(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just after movement of a child in the tree by changing its parent or by changing its position in the same parent.<br>
@@ -127,7 +129,7 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void childMoved(PsiTreeChangeEvent event);
+  void childMoved(@NotNull PsiTreeChangeEvent event);
 
   /**
    * Invoked just after changing of some property of an element.<br>
@@ -138,5 +140,5 @@ public interface PsiTreeChangeListener extends EventListener {
    *
    * @param event the event object describing the change.
    */
-  void propertyChanged(PsiTreeChangeEvent event);
+  void propertyChanged(@NotNull PsiTreeChangeEvent event);
 }

platform/core-impl/src/com/intellij/openapi/editor/impl/IntervalTreeImpl.java

@@ -58,6 +58,11 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     protected int delta;  // delta of startOffset. getStartOffset() = myStartOffset + Sum of deltas up to root
 
     private volatile long cachedDeltaUpToRoot; // field (packed to long for atomicity) containing deltaUpToRoot, node modCount and allDeltasUpAreNull flag
+    // fields are packed as following
+    //  private int modCount; // if it equals to the com.intellij.openapi.editor.impl.RedBlackTree.modCount then deltaUpToRoot can be used, otherwise it is expired
+    //  private int deltaUpToRoot; // sum of all deltas up to the root (including this node' delta). Has valid value only if modCount == IntervalTreeImpl.this.modCount
+    //  private boolean allDeltasUpAreNull;  // true if all deltas up the tree (including this node) are 0. Has valid value only if modCount == IntervalTreeImpl.this.modCount
+
     private final IntervalTreeImpl<E> myIntervalTree;
 
     public IntervalNode(IntervalTreeImpl<E> intervalTree, @NotNull E key, int start, int end) {
@@ -167,16 +172,13 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     }
 
     protected int computeDeltaUpToRoot() {
-      return computeDeltaUpToRoot(new NodeCachedOffsets());
-    }
-    protected int computeDeltaUpToRoot(NodeCachedOffsets cached) {
       restart:
       while (true) { // have to restart on failure to update cached offsets in case of concurrent modification
         if (!isValid()) return 0;
         int treeModCount = myIntervalTree.modCount;
-        unpackCachedValuesTo(cached);
-        if (cached.modCount == treeModCount) {
-          return cached.deltaUpToRoot;
+        long packedOffsets = cachedDeltaUpToRoot;
+        if (modCount(packedOffsets) == treeModCount) {
+          return deltaUpToRoot(packedOffsets);
         }
         try {
           myIntervalTree.l.readLock().lock();
@@ -189,10 +191,10 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
           int height = 0;
           long path = 0; // path to this node from the root; 0 bit means we choose left subtree, 1 bit means we choose right subtree
           while (node != treeRoot) {
-            node.unpackCachedValuesTo(cached);
-            if (node.isValid() && cached.modCount == treeModCount) {
-              deltaUp = cached.deltaUpToRoot - node.delta;
-              allDeltasAreNull = cached.allDeltasUpAreNull;
+            long nodePackedOffsets = node.cachedDeltaUpToRoot;
+            if (node.isValid() && modCount(nodePackedOffsets) == treeModCount) {
+              deltaUp = deltaUpToRoot(nodePackedOffsets) - node.delta;
+              allDeltasAreNull = allDeltasUpAreNull(nodePackedOffsets);
               break;
             }
             IntervalNode<E> parent = node.getParent();
@@ -305,11 +307,14 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
       return cachedDeltaUpdater.compareAndSetLong(this, oldValue, newValue);
     }
 
-    public void unpackCachedValuesTo(NodeCachedOffsets t) {
-      long value = cachedDeltaUpToRoot;
-      t.deltaUpToRoot = (int)(value >> 33);
-      t.modCount = (int)value;
-      t.allDeltasUpAreNull = ((value >> 32) & 1) != 0;
+    private static boolean allDeltasUpAreNull(long packedOffsets) {
+      return ((packedOffsets >> 32) & 1) != 0;
+    }
+    private static int modCount(long packedOffsets) {
+      return (int)packedOffsets;
+    }
+    private static int deltaUpToRoot(long packedOffsets) {
+      return (int)(packedOffsets >> 33);
     }
 
     @NonNls
@@ -319,12 +324,6 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     }
   }
 
-  static class NodeCachedOffsets {
-    private int modCount; // if it equals to the com.intellij.openapi.editor.impl.RedBlackTree.modCount then deltaUpToRoot can be used, otherwise it is expired
-    private int deltaUpToRoot; // sum of all deltas up to the root (including this node' delta). Has valid value only if modCount == IntervalTreeImpl.this.modCount
-    private boolean allDeltasUpAreNull;  // true if all deltas up the tree (including this node) are 0. Has valid value only if modCount == IntervalTreeImpl.this.modCount
-  }
-
   private void assertUnderWriteLock() {
     assert isAcquired(l.writeLock()) : l.writeLock();
   }
@@ -333,12 +332,12 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     return s.contains("Locked by thread");
   }
 
-  private void pushDeltaFromRoot(IntervalNode<T> node, NodeCachedOffsets cached) {
+  private void pushDeltaFromRoot(IntervalNode<T> node) {
     if (node != null) {
-      node.unpackCachedValuesTo(cached);
-      if (cached.allDeltasUpAreNull && node.isValid() && cached.modCount == modCount) return;
-      pushDeltaFromRoot(node.getParent(), cached);
-      pushDelta(node, cached);
+      long packedOffsets = node.cachedDeltaUpToRoot;
+      if (IntervalNode.allDeltasUpAreNull(packedOffsets) && node.isValid() && IntervalNode.modCount(packedOffsets) == modCount) return;
+      pushDeltaFromRoot(node.getParent());
+      pushDelta(node);
     }
   }
 
@@ -672,14 +671,13 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     node.setRight(null);
 
     List<IntervalNode<T>> gced = new SmartList<IntervalNode<T>>();
-    NodeCachedOffsets cached = new NodeCachedOffsets();
     if (root == null) {
       root = node;
     }
     else {
       IntervalNode<T> current = getRoot();
       while (true) {
-        pushDelta(current, cached);
+        pushDelta(current);
         int compResult = compareNodes(node, 0, current, 0, gced);
         if (compResult == 0) {
           return current;
@@ -702,7 +700,7 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
       node.setParent(current);
     }
     node.setCachedValues(0, true, modCount);
-    correctMaxUp(node, cached);
+    correctMaxUp(node);
     onInsertNode();
     keySize += node.intervals.size();
     insertCase1(node);
@@ -782,11 +780,10 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
                                                     int[] nodeCounter,
                                                     TLongHashSet ids, boolean allDeltasUpAreNull) {
     if (root == null) return Trinity.create(Integer.MAX_VALUE,Integer.MIN_VALUE,Integer.MIN_VALUE);
-    NodeCachedOffsets cached = new NodeCachedOffsets();
-    root.unpackCachedValuesTo(cached);
-    if (cached.modCount == modCount) {
-      assert cached.allDeltasUpAreNull == (root.delta == 0 && allDeltasUpAreNull);
-      assert cached.deltaUpToRoot == root.delta + deltaUpToRootExclusive;
+    long packedOffsets = root.cachedDeltaUpToRoot;
+    if (IntervalNode.modCount(packedOffsets) == modCount) {
+      assert IntervalNode.allDeltasUpAreNull(packedOffsets) == (root.delta == 0 && allDeltasUpAreNull);
+      assert IntervalNode.deltaUpToRoot(packedOffsets) == root.delta + deltaUpToRootExclusive;
     }
     T liveInterval = null;
     for (int i = root.intervals.size() - 1; i >= 0; i--) {
@@ -839,12 +836,11 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
   @Override
   protected Node<T> maximumNode(Node<T> n) {
     IntervalNode<T> root = (IntervalNode<T>)n;
-    NodeCachedOffsets cached = new NodeCachedOffsets();
-    pushDelta(root.getParent(), cached);
-    pushDelta(root, cached);
+    pushDelta(root.getParent());
+    pushDelta(root);
     while (root.getRight() != null) {
       root = root.getRight();
-      pushDelta(root, cached);
+      pushDelta(root);
     }
     return root;
   }
@@ -906,16 +902,15 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
   void removeNode(@NotNull IntervalNode<T> node) {
     deleteNode(node);
     IntervalNode<T> parent = node.getParent();
-    correctMaxUp(parent, new NodeCachedOffsets());
+    correctMaxUp(parent);
   }
 
   @Override
   protected void deleteNode(@NotNull Node<T> n) {
     assertUnderWriteLock();
     IntervalNode<T> node = (IntervalNode<T>)n;
-    NodeCachedOffsets cached = new NodeCachedOffsets();
-    pushDeltaFromRoot(node, cached);
-    assertAllDeltasAreNull(node, cached);
+    pushDeltaFromRoot(node);
+    assertAllDeltasAreNull(node);
     super.deleteNode(n);
 
     keySize -= node.intervals.size();
@@ -928,10 +923,10 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
   }
 
   // returns true if all deltas involved are still 0
-  protected boolean pushDelta(IntervalNode<T> root, NodeCachedOffsets cached) {
+  protected boolean pushDelta(IntervalNode<T> root) {
     if (root == null || !root.isValid()) return true;
     IntervalNode<T> parent = root.getParent();
-    assertAllDeltasAreNull(parent, cached);
+    assertAllDeltasAreNull(parent);
     int delta = root.delta;
     root.setCachedValues(0, true, 0);
     if (delta != 0) {
@@ -984,7 +979,7 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     //correctMaxUp(a);
     a.color = dcolor;
     d.color = acolor;
-    correctMaxUp(a, new NodeCachedOffsets());
+    correctMaxUp(a);
 
     checkMax(false);
     assert a.delta == 0 : a.delta;
@@ -1044,8 +1039,8 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     node.maxEnd = realMax - deltaUpToRoot;
   }
 
-  private void correctMaxUp(IntervalNode<T> node, NodeCachedOffsets cached) {
-    int delta = node == null ? 0 : node.computeDeltaUpToRoot(cached);
+  private void correctMaxUp(IntervalNode<T> node) {
+    int delta = node == null ? 0 : node.computeDeltaUpToRoot();
     assert delta == 0 : delta;
     while (node != null) {
       if (node.isValid()) {
@@ -1065,12 +1060,11 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     IntervalNode<T> node2 = node1.getLeft();
     IntervalNode<T> node3 = node1.getRight();
 
-    NodeCachedOffsets cached = new NodeCachedOffsets();
     IntervalNode<T> parent = node1.getParent();
-    int deltaUp = parent == null ? 0 : parent.computeDeltaUpToRoot(cached);
-    pushDelta(node1, cached);
-    pushDelta(node2, cached);
-    pushDelta(node3, cached);
+    int deltaUp = parent == null ? 0 : parent.computeDeltaUpToRoot();
+    pushDelta(node1);
+    pushDelta(node2);
+    pushDelta(node3);
 
     super.rotateRight(node1);
 
@@ -1079,9 +1073,9 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     }
     correctMax(node1, deltaUp);
     correctMax(node2, deltaUp);
-    assertAllDeltasAreNull(node1, cached);
-    assertAllDeltasAreNull(node2, cached);
-    assertAllDeltasAreNull(node3, cached);
+    assertAllDeltasAreNull(node1);
+    assertAllDeltasAreNull(node2);
+    assertAllDeltasAreNull(node3);
     checkMax(false);
   }
 
@@ -1092,12 +1086,11 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     IntervalNode<T> node2 = node1.getLeft();
     IntervalNode<T> node3 = node1.getRight();
 
-    NodeCachedOffsets cached = new NodeCachedOffsets();
     IntervalNode<T> parent = node1.getParent();
-    int deltaUp = parent == null ? 0 : parent.computeDeltaUpToRoot(cached);
-    pushDelta(node1, cached);
-    pushDelta(node2, cached);
-    pushDelta(node3, cached);
+    int deltaUp = parent == null ? 0 : parent.computeDeltaUpToRoot();
+    pushDelta(node1);
+    pushDelta(node2);
+    pushDelta(node3);
     checkMax(false);
     super.rotateLeft(node1);
 
@@ -1106,9 +1099,9 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     }
     correctMax(node1, deltaUp);
     correctMax(node3, deltaUp);
-    assertAllDeltasAreNull(node1, cached);
-    assertAllDeltasAreNull(node2, cached);
-    assertAllDeltasAreNull(node3, cached);
+    assertAllDeltasAreNull(node1);
+    assertAllDeltasAreNull(node2);
+    assertAllDeltasAreNull(node3);
 
     checkMax(false);
   }
@@ -1116,9 +1109,8 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
   @Override
   protected void replaceNode(@NotNull Node<T> node, Node<T> child) {
     IntervalNode<T> myNode = (IntervalNode<T>)node;
-    NodeCachedOffsets cached = new NodeCachedOffsets();
-    pushDelta(myNode, cached);
-    pushDelta((IntervalNode<T>)child, cached);
+    pushDelta(myNode);
+    pushDelta((IntervalNode<T>)child);
 
     super.replaceNode(node, child);
     if (child != null && myNode.isValid()) {
@@ -1127,12 +1119,12 @@ public abstract class IntervalTreeImpl<T extends MutableInterval> extends RedBla
     }
   }
 
-  private void assertAllDeltasAreNull(IntervalNode<T> node, NodeCachedOffsets cached) {
+  private void assertAllDeltasAreNull(IntervalNode<T> node) {
     if (node == null) return;
     if (!node.isValid()) return;
     assert node.delta == 0;
-    node.unpackCachedValuesTo(cached);
-    assert cached.modCount != modCount || cached.allDeltasUpAreNull;
+    long packedOffsets = node.cachedDeltaUpToRoot;
+    assert IntervalNode.modCount(packedOffsets) != modCount || IntervalNode.allDeltasUpAreNull(packedOffsets);
   }
 
   private IntervalNode<T> findMinOverlappingWith(IntervalNode<T> root, Interval interval, int modCountBefore, int deltaUpToRootExclusive) {

platform/core-impl/src/com/intellij/openapi/editor/impl/RangeMarkerTree.java

@@ -187,7 +187,7 @@ public class RangeMarkerTree<T extends RangeMarkerEx> extends IntervalTreeImpl<T
 
       modCount++;
       List<IntervalNode<T>> affected = new SmartList<IntervalNode<T>>();
-      collectAffectedMarkersAndShiftSubtrees(getRoot(), e, affected, new NodeCachedOffsets());
+      collectAffectedMarkersAndShiftSubtrees(getRoot(), e, affected);
       checkMax(false);
 
       if (!affected.isEmpty()) {
@@ -257,9 +257,9 @@ public class RangeMarkerTree<T extends RangeMarkerEx> extends IntervalTreeImpl<T
   // returns true if all deltas involved are still 0
   private boolean collectAffectedMarkersAndShiftSubtrees(IntervalNode<T> root,
                                                          @NotNull DocumentEvent e,
-                                                         @NotNull List<IntervalNode<T>> affected, NodeCachedOffsets cached) {
+                                                         @NotNull List<IntervalNode<T>> affected) {
     if (root == null) return true;
-    boolean norm = pushDelta(root, cached);
+    boolean norm = pushDelta(root);
 
     int maxEnd = root.maxEnd;
     assert root.isValid();
@@ -284,8 +284,8 @@ public class RangeMarkerTree<T extends RangeMarkerEx> extends IntervalTreeImpl<T
         int newL = left.changeDelta(-lengthDelta);
         norm &= newL == 0;
       }
-      norm &= pushDelta(root, cached);
-      norm &= collectAffectedMarkersAndShiftSubtrees(left, e, affected, cached);
+      norm &= pushDelta(root);
+      norm &= collectAffectedMarkersAndShiftSubtrees(left, e, affected);
       correctMax(root, 0);
     }
     else {
@@ -295,8 +295,8 @@ public class RangeMarkerTree<T extends RangeMarkerEx> extends IntervalTreeImpl<T
         root.setValid(false);  //make invisible
       }
 
-      norm &= collectAffectedMarkersAndShiftSubtrees(root.getLeft(), e, affected, cached);
-      norm &= collectAffectedMarkersAndShiftSubtrees(root.getRight(), e, affected, cached);
+      norm &= collectAffectedMarkersAndShiftSubtrees(root.getLeft(), e, affected);
+      norm &= collectAffectedMarkersAndShiftSubtrees(root.getRight(), e, affected);
       correctMax(root,0);
     }
     return norm;

platform/core-impl/src/com/intellij/psi/impl/source/PsiFileImpl.java

@@ -249,15 +249,12 @@ public abstract class PsiFileImpl extends ElementBase implements PsiFileEx, PsiF
     return findTreeForStub(ast, stubs, stub);
   }
 
-  public boolean isStubBasedChildValid(@NotNull StubBasedPsiElementBase psi) {
-    StubElement fileStub = getStub();
-    if (fileStub != null) {
-      synchronized (myStubLock) {
-        fileStub = getStub();
-        StubElement childStub = psi.getStub();
-        if (fileStub != null && childStub != null && fileStub != childStub.getParentStub()) {
-          return false;
-        }
+  public boolean isStubBasedChildValid(@NotNull StubBasedPsiElementBase child) {
+    synchronized (myStubLock) {
+      StubTree fileStub = derefStub();
+      StubElement childStub = child.getStub();
+      if (childStub != null && (fileStub == null || fileStub.getRoot() != childStub.getParentStub())) {
+        return false;
       }
     }
     return isValid();

platform/lang-api/src/com/intellij/codeInspection/InspectionProfileEntry.java

@@ -52,8 +52,6 @@ public abstract class InspectionProfileEntry {
   private Boolean myUseNewSerializer = null;
 
   /**
-   * DO NOT OVERRIDE this method.
-   *
    * @see InspectionEP#groupDisplayName
    * @see InspectionEP#groupKey
    * @see InspectionEP#groupBundle
@@ -64,8 +62,6 @@ public abstract class InspectionProfileEntry {
   }
 
   /**
-   * DO NOT OVERRIDE this method.
-   *
    * @see InspectionEP#groupPath
    */
   @NotNull
@@ -78,8 +74,6 @@ public abstract class InspectionProfileEntry {
   }
 
   /**
-   * DO NOT OVERRIDE this method.
-   *
    * @see InspectionEP#displayName
    * @see InspectionEP#key
    * @see InspectionEP#bundle

platform/lang-api/src/com/intellij/psi/PsiTreeChangeAdapter.java

@@ -15,43 +15,45 @@
  */
 package com.intellij.psi;
 
+import org.jetbrains.annotations.NotNull;
+
 /**
  * Default empty implementation of {@link PsiTreeChangeListener}.
  */
 public abstract class PsiTreeChangeAdapter implements PsiTreeChangeListener {
-  public void beforeChildAddition(PsiTreeChangeEvent event) {
+  public void beforeChildAddition(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void beforeChildRemoval(PsiTreeChangeEvent event) {
+  public void beforeChildRemoval(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void beforeChildReplacement(PsiTreeChangeEvent event) {
+  public void beforeChildReplacement(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void beforeChildMovement(PsiTreeChangeEvent event) {
+  public void beforeChildMovement(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void beforeChildrenChange(PsiTreeChangeEvent event) {
+  public void beforeChildrenChange(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void beforePropertyChange(PsiTreeChangeEvent event) {
+  public void beforePropertyChange(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void childAdded(PsiTreeChangeEvent event) {
+  public void childAdded(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void childRemoved(PsiTreeChangeEvent event) {
+  public void childRemoved(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void childReplaced(PsiTreeChangeEvent event) {
+  public void childReplaced(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void childMoved(PsiTreeChangeEvent event) {
+  public void childMoved(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void childrenChanged(PsiTreeChangeEvent event) {
+  public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
   }
 
-  public void propertyChanged(PsiTreeChangeEvent event) {
+  public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
   }
 }

platform/lang-api/src/com/intellij/psi/search/scope/packageSet/FilePatternPackageSet.java

@@ -28,10 +28,10 @@ import com.intellij.openapi.roots.ProjectFileIndex;
 import com.intellij.openapi.roots.ProjectRootManager;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.text.StringUtil;
-import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.regex.Pattern;
 
@@ -74,7 +74,9 @@ public class FilePatternPackageSet extends PatternBasedPackageSet {
   }
 
   private boolean fileMatcher(VirtualFile virtualFile, ProjectFileIndex fileIndex, VirtualFile projectBaseDir){
-    return myFilePattern.matcher(getRelativePath(virtualFile, fileIndex, true, projectBaseDir)).matches();
+    final String relativePath = getRelativePath(virtualFile, fileIndex, true, projectBaseDir);
+    LOG.assertTrue(relativePath != null, "vFile: " + virtualFile + "; projectBaseDir: " + projectBaseDir);
+    return myFilePattern.matcher(relativePath).matches();
   }
 
   public static boolean matchesModule(final Pattern moduleGroupPattern,
@@ -183,6 +185,7 @@ public class FilePatternPackageSet extends PatternBasedPackageSet {
     return Comparing.strEqual(myPathPattern, oldQName);
   }
 
+  @Nullable
   public static String getRelativePath(final VirtualFile virtualFile,
                                        final ProjectFileIndex index,
                                        final boolean useFQName,
@@ -194,7 +197,7 @@ public class FilePatternPackageSet extends PatternBasedPackageSet {
     final Module module = index.getModuleForFile(virtualFile);
     if (module != null) {
       if (projectBaseDir != null) {
-        if (VfsUtil.isAncestor(projectBaseDir, virtualFile, false)){
+        if (VfsUtilCore.isAncestor(projectBaseDir, virtualFile, false)){
           final String projectRelativePath = VfsUtilCore.getRelativePath(virtualFile, projectBaseDir, '/');
           return useFQName ? projectRelativePath : projectRelativePath.substring(projectRelativePath.indexOf('/') + 1);
         }

platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/PsiChangeHandler.java

@@ -124,17 +124,17 @@ public class PsiChangeHandler extends PsiTreeChangeAdapter implements Disposable
   }
 
   @Override
-  public void childAdded(PsiTreeChangeEvent event) {
+  public void childAdded(@NotNull PsiTreeChangeEvent event) {
     queueElement(event.getParent(), true, event);
   }
 
   @Override
-  public void childRemoved(PsiTreeChangeEvent event) {
+  public void childRemoved(@NotNull PsiTreeChangeEvent event) {
     queueElement(event.getParent(), true, event);
   }
 
   @Override
-  public void childReplaced(PsiTreeChangeEvent event) {
+  public void childReplaced(@NotNull PsiTreeChangeEvent event) {
     queueElement(event.getNewChild(), typesEqual(event.getNewChild(), event.getOldChild()), event);
   }
 
@@ -143,7 +143,7 @@ public class PsiChangeHandler extends PsiTreeChangeAdapter implements Disposable
   }
 
   @Override
-  public void childrenChanged(PsiTreeChangeEvent event) {
+  public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
     if (((PsiTreeChangeEventImpl)event).isGenericChildrenChange()) {
       return;
     }
@@ -151,13 +151,13 @@ public class PsiChangeHandler extends PsiTreeChangeAdapter implements Disposable
   }
 
   @Override
-  public void beforeChildMovement(PsiTreeChangeEvent event) {
+  public void beforeChildMovement(@NotNull PsiTreeChangeEvent event) {
     queueElement(event.getOldParent(), true, event);
     queueElement(event.getNewParent(), true, event);
   }
 
   @Override
-  public void beforeChildrenChange(PsiTreeChangeEvent event) {
+  public void beforeChildrenChange(@NotNull PsiTreeChangeEvent event) {
     // this event sent always before every PSI change, even not significant one (like after quick typing/backspacing char)
     // mark file dirty just in case
     PsiFile psiFile = event.getFile();
@@ -167,7 +167,7 @@ public class PsiChangeHandler extends PsiTreeChangeAdapter implements Disposable
   }
 
   @Override
-  public void propertyChanged(PsiTreeChangeEvent event) {
+  public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
     String propertyName = event.getPropertyName();
     if (!propertyName.equals(PsiTreeChangeEvent.PROP_WRITABLE)) {
       myFileStatusMap.markAllFilesDirty();

platform/lang-impl/src/com/intellij/codeInsight/daemon/impl/actions/GotoNextErrorAction.java

@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package com.intellij.codeInsight.daemon.impl.actions;
 
 import com.intellij.codeInsight.CodeInsightActionHandler;
@@ -27,7 +25,6 @@ import com.intellij.openapi.project.DumbAware;
 import com.intellij.psi.PsiFile;
 
 public class GotoNextErrorAction extends BaseCodeInsightAction implements DumbAware {
-
   public GotoNextErrorAction() {
     super(false);
   }

platform/lang-impl/src/com/intellij/codeInsight/navigation/CtrlMouseHandler.java

@@ -398,7 +398,7 @@ public class CtrlMouseHandler extends AbstractProjectComponent {
         }
         else if (targetElements.length == 1) {
           if (targetElements[0] != resolvedElement && elementAtPointer != null && targetElements[0].isPhysical()) {
-            return new InfoSingle(elementAtPointer, targetElements[0]);
+            return ref != null ? new InfoSingle(ref, targetElements[0]) : new InfoSingle(elementAtPointer, targetElements[0]);
           }
         }
         else {

platform/lang-impl/src/com/intellij/codeInsight/problems/WolfTheProblemSolverImpl.java

@@ -122,27 +122,27 @@ public class WolfTheProblemSolverImpl extends WolfTheProblemSolver {
   public WolfTheProblemSolverImpl(Project project, PsiManager psiManager, VirtualFileManager virtualFileManager) {
     myProject = project;
     PsiTreeChangeListener changeListener = new PsiTreeChangeAdapter() {
-      public void childAdded(PsiTreeChangeEvent event) {
+      public void childAdded(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void childRemoved(PsiTreeChangeEvent event) {
+      public void childRemoved(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void childReplaced(PsiTreeChangeEvent event) {
+      public void childReplaced(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void childMoved(PsiTreeChangeEvent event) {
+      public void childMoved(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void propertyChanged(PsiTreeChangeEvent event) {
+      public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void childrenChanged(PsiTreeChangeEvent event) {
+      public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
         clearSyntaxErrorFlag(event);
       }
     };

platform/lang-impl/src/com/intellij/codeInsight/template/actions/SaveAsTemplateAction.java

@@ -31,6 +31,7 @@ import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.command.CommandProcessor;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
@@ -48,6 +49,8 @@ import java.util.Set;
 
 public class SaveAsTemplateAction extends AnAction {
 
+  private static final Logger LOG = Logger.getInstance("#" + SaveAsTemplateAction.class.getName());
+
   public void actionPerformed(AnActionEvent e) {
     DataContext dataContext = e.getDataContext();
     final Editor editor = PlatformDataKeys.EDITOR.getData(dataContext);
@@ -89,7 +92,9 @@ public class SaveAsTemplateAction extends AnAction {
                 if (!(reference instanceof PsiQualifiedReference) || ((PsiQualifiedReference) reference).getQualifier() == null) {
                   String canonicalText = reference.getCanonicalText();
                   TextRange referenceRange = reference.getRangeInElement();
-                  TextRange range = element.getTextRange().cutOut(referenceRange).shiftRight(-offsetDelta);
+                  final TextRange elementTextRange = element.getTextRange();
+                  LOG.assertTrue(elementTextRange != null, elementTextRange);
+                  final TextRange range = elementTextRange.cutOut(referenceRange).shiftRight(-offsetDelta);
                   final String oldText = document.getText(range);
                   // workaround for Java references: canonicalText contains generics, and we need to cut them off because otherwise
                   // they will be duplicated

platform/lang-impl/src/com/intellij/codeInsight/template/impl/TemplateState.java

@@ -831,8 +831,8 @@ public class TemplateState implements Disposable {
     if (selStart >= 0 && selEnd >= 0) {
       myEditor.getSelectionModel().setSelection(mySegments.getSegmentStart(selStart), mySegments.getSegmentStart(selEnd));
     }
-    fireBeforeTemplateFinished();
     final Editor editor = myEditor;
+    fireBeforeTemplateFinished();
     int oldVar = myCurrentVariableNumber;
     setCurrentVariableNumber(-1);
     currentVariableChanged(oldVar);

platform/lang-impl/src/com/intellij/find/findUsages/FindUsagesManager.java

@@ -403,7 +403,7 @@ public class FindUsagesManager implements JDOMExternalizable {
               .processRequests(options.fastTrack, new ReadActionProcessor<PsiReference>() {
                 @Override
                 public boolean processInReadAction(final PsiReference ref) {
-                  return usageInfoProcessor.process(new UsageInfo(ref));
+                  return !ref.getElement().isValid() || usageInfoProcessor.process(new UsageInfo(ref));
                 }
               });
         }

platform/lang-impl/src/com/intellij/ide/actions/GotoRelatedFileAction.java

@@ -174,6 +174,16 @@ public class GotoRelatedFileAction extends AnAction {
         return true;
       }
 
+      @Override
+      public String getIndexedString(Object value) {
+        if (value instanceof GotoRelatedItem) {
+          //noinspection ConstantConditions
+          return ((GotoRelatedItem)value).getCustomName();
+        }
+        final PsiElement element = (PsiElement)value;
+        return renderer.getElementText(element) + " " + renderer.getContainerText(element, null);
+      }
+
       @Override
       public PopupStep onChosen(Object selectedValue, boolean finalChoice) {
         processor.process(selectedValue);

platform/lang-impl/src/com/intellij/ide/bookmarks/actions/BookmarksAction.java

@@ -195,7 +195,7 @@ public class BookmarksAction extends AnAction implements DumbAware {
 
     ActionToolbar actionToolbar = ActionManager.getInstance().createActionToolbar("", actions, true);
     actionToolbar.setReservePlaceAutoPopupIcon(false);
-    actionToolbar.setMinimumButtonSize(new Dimension(16, 16));
+    actionToolbar.setMinimumButtonSize(new Dimension(20, 20));
     final JComponent toolBar = actionToolbar.getComponent();
     toolBar.setOpaque(false);
 

platform/lang-impl/src/com/intellij/ide/commander/ProjectListBuilder.java

@@ -31,6 +31,7 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.util.Alarm;
+import org.jetbrains.annotations.NotNull;
 
 import java.awt.datatransfer.Transferable;
 import java.util.ArrayList;
@@ -146,30 +147,30 @@ public class ProjectListBuilder extends AbstractListBuilder {
       myOutOfCodeBlockModificationCount = myModificationTracker.getOutOfCodeBlockModificationCount();
     }
 
-    public void childRemoved(final PsiTreeChangeEvent event) {
+    public void childRemoved(@NotNull final PsiTreeChangeEvent event) {
       final PsiElement child = event.getOldChild();
       if (child instanceof PsiWhiteSpace) return; //optimization
       childrenChanged();
     }
 
-    public void childAdded(final PsiTreeChangeEvent event) {
+    public void childAdded(@NotNull final PsiTreeChangeEvent event) {
       final PsiElement child = event.getNewChild();
       if (child instanceof PsiWhiteSpace) return; //optimization
       childrenChanged();
     }
 
-    public void childReplaced(final PsiTreeChangeEvent event) {
+    public void childReplaced(@NotNull final PsiTreeChangeEvent event) {
       final PsiElement oldChild = event.getOldChild();
       final PsiElement newChild = event.getNewChild();
       if (oldChild instanceof PsiWhiteSpace && newChild instanceof PsiWhiteSpace) return; //optimization
       childrenChanged();
     }
 
-    public void childMoved(final PsiTreeChangeEvent event) {
+    public void childMoved(@NotNull final PsiTreeChangeEvent event) {
       childrenChanged();
     }
 
-    public void childrenChanged(final PsiTreeChangeEvent event) {
+    public void childrenChanged(@NotNull final PsiTreeChangeEvent event) {
       childrenChanged();
     }
 
@@ -180,7 +181,7 @@ public class ProjectListBuilder extends AbstractListBuilder {
       addUpdateRequest();
     }
 
-    public void propertyChanged(final PsiTreeChangeEvent event) {
+    public void propertyChanged(@NotNull final PsiTreeChangeEvent event) {
       final String propertyName = event.getPropertyName();
       if (propertyName.equals(PsiTreeChangeEvent.PROP_ROOTS)) {
         addUpdateRequest();

platform/lang-impl/src/com/intellij/ide/favoritesTreeView/FavoritesManager.java

@@ -378,7 +378,7 @@ public class FavoritesManager implements ProjectComponent, JDOMExternalizable {
   }
 
   private class MyRootsChangeAdapter extends PsiTreeChangeAdapter {
-    public void beforeChildMovement(final PsiTreeChangeEvent event) {
+    public void beforeChildMovement(@NotNull final PsiTreeChangeEvent event) {
       final PsiElement oldParent = event.getOldParent();
       final PsiElement newParent = event.getNewParent();
       final PsiElement child = event.getChild();
@@ -417,7 +417,7 @@ public class FavoritesManager implements ProjectComponent, JDOMExternalizable {
       }
     }
 
-    public void beforePropertyChange(final PsiTreeChangeEvent event) {
+    public void beforePropertyChange(@NotNull final PsiTreeChangeEvent event) {
       if (event.getPropertyName().equals(PsiTreeChangeEvent.PROP_FILE_NAME) || event.getPropertyName().equals(PsiTreeChangeEvent.PROP_DIRECTORY_NAME)) {
         final PsiElement psiElement = event.getChild();
         if (psiElement instanceof PsiFile || psiElement instanceof PsiDirectory) {

platform/lang-impl/src/com/intellij/ide/hierarchy/HierarchyTreeBuilder.java

@@ -110,27 +110,27 @@ public class HierarchyTreeBuilder extends AbstractTreeBuilder {
   }
 
   private final class MyPsiTreeChangeListener extends PsiTreeChangeAdapter {
-    public final void childAdded(final PsiTreeChangeEvent event) {
+    public final void childAdded(@NotNull final PsiTreeChangeEvent event) {
       getUpdater().addSubtreeToUpdate(getRootNode());
     }
 
-    public final void childRemoved(final PsiTreeChangeEvent event) {
+    public final void childRemoved(@NotNull final PsiTreeChangeEvent event) {
       getUpdater().addSubtreeToUpdate(getRootNode());
     }
 
-    public final void childReplaced(final PsiTreeChangeEvent event) {
+    public final void childReplaced(@NotNull final PsiTreeChangeEvent event) {
       getUpdater().addSubtreeToUpdate(getRootNode());
     }
 
-    public final void childMoved(final PsiTreeChangeEvent event) {
+    public final void childMoved(@NotNull final PsiTreeChangeEvent event) {
       getUpdater().addSubtreeToUpdate(getRootNode());
     }
 
-    public final void childrenChanged(final PsiTreeChangeEvent event) {
+    public final void childrenChanged(@NotNull final PsiTreeChangeEvent event) {
       getUpdater().addSubtreeToUpdate(getRootNode());
     }
 
-    public final void propertyChanged(final PsiTreeChangeEvent event) {
+    public final void propertyChanged(@NotNull final PsiTreeChangeEvent event) {
       getUpdater().addSubtreeToUpdate(getRootNode());
     }
   }

platform/lang-impl/src/com/intellij/ide/navigationToolbar/NavBarListener.java

@@ -184,23 +184,23 @@ public class NavBarListener extends WolfTheProblemSolver.ProblemListener
     rebuildUI();
   }
 
-  public void childAdded(PsiTreeChangeEvent event) {
+  public void childAdded(@NotNull PsiTreeChangeEvent event) {
     updateModel();
   }
 
-  public void childReplaced(PsiTreeChangeEvent event) {
+  public void childReplaced(@NotNull PsiTreeChangeEvent event) {
     updateModel();
   }
 
-  public void childMoved(PsiTreeChangeEvent event) {
+  public void childMoved(@NotNull PsiTreeChangeEvent event) {
     updateModel();
   }
 
-  public void childrenChanged(PsiTreeChangeEvent event) {
+  public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
     updateModel();
   }
 
-  public void propertyChanged(final PsiTreeChangeEvent event) {
+  public void propertyChanged(@NotNull final PsiTreeChangeEvent event) {
     updateModel();
   }
 
@@ -267,23 +267,23 @@ public class NavBarListener extends WolfTheProblemSolver.ProblemListener
   public void beforeRootsChange(ModuleRootEvent event) {}
 
   @Override
-  public void beforeChildAddition(PsiTreeChangeEvent event) {}
+  public void beforeChildAddition(@NotNull PsiTreeChangeEvent event) {}
 
   @Override
-  public void beforeChildRemoval(PsiTreeChangeEvent event) {}
+  public void beforeChildRemoval(@NotNull PsiTreeChangeEvent event) {}
 
   @Override
-  public void beforeChildReplacement(PsiTreeChangeEvent event) {}
+  public void beforeChildReplacement(@NotNull PsiTreeChangeEvent event) {}
 
   @Override
-  public void beforeChildMovement(PsiTreeChangeEvent event) {}
+  public void beforeChildMovement(@NotNull PsiTreeChangeEvent event) {}
 
   @Override
-  public void beforeChildrenChange(PsiTreeChangeEvent event) {}
+  public void beforeChildrenChange(@NotNull PsiTreeChangeEvent event) {}
 
   @Override
-  public void beforePropertyChange(PsiTreeChangeEvent event) {}
+  public void beforePropertyChange(@NotNull PsiTreeChangeEvent event) {}
 
   @Override
-  public void childRemoved(PsiTreeChangeEvent event) {}
+  public void childRemoved(@NotNull PsiTreeChangeEvent event) {}
 }

platform/lang-impl/src/com/intellij/ide/projectView/ProjectViewPsiTreeChangeListener.java

@@ -23,6 +23,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiModificationTracker;
+import org.jetbrains.annotations.NotNull;
 
 import javax.swing.tree.DefaultMutableTreeNode;
 
@@ -43,31 +44,31 @@ public abstract class ProjectViewPsiTreeChangeListener extends PsiTreeChangeAdap
 
   protected abstract DefaultMutableTreeNode getRootNode();
 
-  public final void childRemoved(PsiTreeChangeEvent event) {
+  public final void childRemoved(@NotNull PsiTreeChangeEvent event) {
     PsiElement child = event.getOldChild();
     if (child instanceof PsiWhiteSpace) return; //optimization
     childrenChanged(event.getParent(), true);
   }
 
-  public final void childAdded(PsiTreeChangeEvent event) {
+  public final void childAdded(@NotNull PsiTreeChangeEvent event) {
     PsiElement child = event.getNewChild();
     if (child instanceof PsiWhiteSpace) return; //optimization
     childrenChanged(event.getParent(), true);
   }
 
-  public final void childReplaced(PsiTreeChangeEvent event) {
+  public final void childReplaced(@NotNull PsiTreeChangeEvent event) {
     PsiElement oldChild = event.getOldChild();
     PsiElement newChild = event.getNewChild();
     if (oldChild instanceof PsiWhiteSpace && newChild instanceof PsiWhiteSpace) return; //optimization
     childrenChanged(event.getParent(), true);
   }
 
-  public final void childMoved(PsiTreeChangeEvent event) {
+  public final void childMoved(@NotNull PsiTreeChangeEvent event) {
     childrenChanged(event.getOldParent(), false);
     childrenChanged(event.getNewParent(), true);
   }
 
-  public final void childrenChanged(PsiTreeChangeEvent event) {
+  public final void childrenChanged(@NotNull PsiTreeChangeEvent event) {
     childrenChanged(event.getParent(), true);
   }
 
@@ -104,7 +105,7 @@ public abstract class ProjectViewPsiTreeChangeListener extends PsiTreeChangeAdap
     }
   }
 
-  public void propertyChanged(PsiTreeChangeEvent event) {
+  public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
     String propertyName = event.getPropertyName();
     PsiElement element = event.getElement();
     DefaultMutableTreeNode rootNode = getRootNode();

platform/lang-impl/src/com/intellij/ide/scopeView/ScopeTreeViewPanel.java

@@ -513,7 +513,7 @@ public class ScopeTreeViewPanel extends JPanel implements Disposable {
   }
 
   private class MyPsiTreeChangeAdapter extends PsiTreeChangeAdapter {
-    public void childAdded(final PsiTreeChangeEvent event) {
+    public void childAdded(@NotNull final PsiTreeChangeEvent event) {
       final PsiElement element = event.getParent();
       final PsiElement child = event.getChild();
       if (child == null) return;
@@ -549,7 +549,7 @@ public class ScopeTreeViewPanel extends JPanel implements Disposable {
       }
     }
 
-    public void beforeChildRemoval(final PsiTreeChangeEvent event) {
+    public void beforeChildRemoval(@NotNull final PsiTreeChangeEvent event) {
       final PsiElement child = event.getChild();
       final PsiElement parent = event.getParent();
       if (parent instanceof PsiDirectory && (child instanceof PsiFile && !isInjected((PsiFile)child) || child instanceof PsiDirectory)) {
@@ -565,7 +565,7 @@ public class ScopeTreeViewPanel extends JPanel implements Disposable {
     }
 
     @Override
-    public void beforeChildMovement(PsiTreeChangeEvent event) {
+    public void beforeChildMovement(@NotNull PsiTreeChangeEvent event) {
       final PsiElement oldParent = event.getOldParent();
       final PsiElement child = event.getChild();
       if (oldParent instanceof PsiDirectory) {
@@ -583,7 +583,7 @@ public class ScopeTreeViewPanel extends JPanel implements Disposable {
       }
     }
 
-    public void childMoved(PsiTreeChangeEvent event) {
+    public void childMoved(@NotNull PsiTreeChangeEvent event) {
       final PsiElement newParent = event.getNewParent();
       final PsiElement child = event.getChild();
       if (newParent instanceof PsiDirectory) {
@@ -611,7 +611,7 @@ public class ScopeTreeViewPanel extends JPanel implements Disposable {
     }
 
 
-    public void childrenChanged(PsiTreeChangeEvent event) {
+    public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
       final PsiElement parent = event.getParent();
       final PsiFile file = parent.getContainingFile();
       if (file != null && file.getFileType() == StdFileTypes.JAVA) {
@@ -631,7 +631,7 @@ public class ScopeTreeViewPanel extends JPanel implements Disposable {
       }
     }
 
-    public final void propertyChanged(PsiTreeChangeEvent event) {
+    public final void propertyChanged(@NotNull PsiTreeChangeEvent event) {
       String propertyName = event.getPropertyName();
       final PsiElement element = event.getElement();
       if (element != null) {
@@ -651,7 +651,7 @@ public class ScopeTreeViewPanel extends JPanel implements Disposable {
       }
     }
 
-    public void childReplaced(final PsiTreeChangeEvent event) {
+    public void childReplaced(@NotNull final PsiTreeChangeEvent event) {
       final NamedScope scope = getCurrentScope();
       final PsiElement element = event.getNewChild();
       final PsiFile psiFile = event.getFile();

platform/lang-impl/src/com/intellij/ide/structureView/impl/TemplateLanguageStructureViewBuilder.java

@@ -62,24 +62,24 @@ public abstract class TemplateLanguageStructureViewBuilder implements StructureV
     myProject = psiElement.getProject();
 
     myPsiTreeChangeAdapter = new PsiTreeChangeAdapter() {
-      public void childAdded(PsiTreeChangeEvent event) {
+      public void childAdded(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void childRemoved(PsiTreeChangeEvent event) {
+      public void childRemoved(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void childReplaced(PsiTreeChangeEvent event) {
+      public void childReplaced(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
-      public void childMoved(PsiTreeChangeEvent event) {
+      public void childMoved(@NotNull PsiTreeChangeEvent event) {
         childrenChanged(event);
       }
 
       final Alarm myAlarm = new Alarm();
-      public void childrenChanged(PsiTreeChangeEvent event) {
+      public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
         myAlarm.cancelAllRequests();
         myAlarm.addRequest(new Runnable(){
           public void run() {

platform/lang-impl/src/com/intellij/ide/structureView/newStructureView/StructureTreeBuilder.java

@@ -136,20 +136,20 @@ public class StructureTreeBuilder extends AbstractTreeBuilder {
       myOutOfCodeBlockModificationCount = myModificationTracker.getOutOfCodeBlockModificationCount();
     }
 
-    public void childRemoved(PsiTreeChangeEvent event) {
+    public void childRemoved(@NotNull PsiTreeChangeEvent event) {
       PsiElement child = event.getOldChild();
       if (child instanceof PsiWhiteSpace) return; //optimization
 
       childrenChanged();
     }
 
-    public void childAdded(PsiTreeChangeEvent event) {
+    public void childAdded(@NotNull PsiTreeChangeEvent event) {
       PsiElement child = event.getNewChild();
       if (child instanceof PsiWhiteSpace) return; //optimization
       childrenChanged();
     }
 
-    public void childReplaced(PsiTreeChangeEvent event) {
+    public void childReplaced(@NotNull PsiTreeChangeEvent event) {
       /** Test comment */
       PsiElement oldChild = event.getOldChild();
       PsiElement newChild = event.getNewChild();
@@ -157,11 +157,11 @@ public class StructureTreeBuilder extends AbstractTreeBuilder {
       childrenChanged();
     }
 
-    public void childMoved(PsiTreeChangeEvent event) {
+    public void childMoved(@NotNull PsiTreeChangeEvent event) {
       childrenChanged();
     }
 
-    public void childrenChanged(PsiTreeChangeEvent event) {
+    public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
       childrenChanged();
     }
 
@@ -172,7 +172,7 @@ public class StructureTreeBuilder extends AbstractTreeBuilder {
       setupUpdateAlarm();
     }
 
-    public void propertyChanged(PsiTreeChangeEvent event) {
+    public void propertyChanged(@NotNull PsiTreeChangeEvent event) {
       childrenChanged();
     }
   }

platform/lang-impl/src/com/intellij/ide/todo/TodoTreeBuilder.java

@@ -658,7 +658,7 @@ public abstract class TodoTreeBuilder extends AbstractTreeBuilder {
   }
 
   private final class MyPsiTreeChangeListener extends PsiTreeChangeAdapter {
-    public void childAdded(PsiTreeChangeEvent e) {
+    public void childAdded(@NotNull PsiTreeChangeEvent e) {
       // If local modification
       if (e.getFile() != null) {
         markFileAsDirty(e.getFile());
@@ -675,7 +675,7 @@ public abstract class TodoTreeBuilder extends AbstractTreeBuilder {
       updateTree(true);
     }
 
-    public void beforeChildRemoval(PsiTreeChangeEvent e) {
+    public void beforeChildRemoval(@NotNull PsiTreeChangeEvent e) {
       // If local midification
       final PsiFile file = e.getFile();
       if (file != null) {
@@ -711,7 +711,7 @@ public abstract class TodoTreeBuilder extends AbstractTreeBuilder {
       }
     }
 
-    public void childMoved(PsiTreeChangeEvent e) {
+    public void childMoved(@NotNull PsiTreeChangeEvent e) {
       if (e.getFile() != null) { // local change
         markFileAsDirty(e.getFile());
         updateTree(true);
@@ -744,21 +744,21 @@ public abstract class TodoTreeBuilder extends AbstractTreeBuilder {
       }
     }
 
-    public void childReplaced(PsiTreeChangeEvent e) {
+    public void childReplaced(@NotNull PsiTreeChangeEvent e) {
       if (e.getFile() != null) {
         markFileAsDirty(e.getFile());
         updateTree(true);
       }
     }
 
-    public void childrenChanged(PsiTreeChangeEvent e) {
+    public void childrenChanged(@NotNull PsiTreeChangeEvent e) {
       if (e.getFile() != null) {
         markFileAsDirty(e.getFile());
         updateTree(true);
       }
     }
 
-    public void propertyChanged(PsiTreeChangeEvent e) {
+    public void propertyChanged(@NotNull PsiTreeChangeEvent e) {
       String propertyName = e.getPropertyName();
       if (propertyName.equals(PsiTreeChangeEvent.PROP_ROOTS)) { // rebuild all tree when source roots were changed
         getUpdater().runBeforeUpdate(

platform/lang-impl/src/com/intellij/openapi/fileEditor/impl/PsiAwareFileEditorManagerImpl.java

@@ -106,7 +106,7 @@ public class PsiAwareFileEditorManagerImpl extends FileEditorManagerImpl {
    * Updates attribute of open files when roots change
    */
   private final class MyPsiTreeChangeListener extends PsiTreeChangeAdapter {
-    public void propertyChanged(final PsiTreeChangeEvent e) {
+    public void propertyChanged(@NotNull final PsiTreeChangeEvent e) {
       if (PsiTreeChangeEvent.PROP_ROOTS.equals(e.getPropertyName())) {
         ApplicationManager.getApplication().assertIsDispatchThread();
         final VirtualFile[] openFiles = getOpenFiles();
@@ -118,23 +118,23 @@ public class PsiAwareFileEditorManagerImpl extends FileEditorManagerImpl {
       }
     }
 
-    public void childAdded(PsiTreeChangeEvent event) {
+    public void childAdded(@NotNull PsiTreeChangeEvent event) {
       doChange(event);
     }
 
-    public void childRemoved(PsiTreeChangeEvent event) {
+    public void childRemoved(@NotNull PsiTreeChangeEvent event) {
       doChange(event);
     }
 
-    public void childReplaced(PsiTreeChangeEvent event) {
+    public void childReplaced(@NotNull PsiTreeChangeEvent event) {
       doChange(event);
     }
 
-    public void childMoved(PsiTreeChangeEvent event) {
+    public void childMoved(@NotNull PsiTreeChangeEvent event) {
       doChange(event);
     }
 
-    public void childrenChanged(PsiTreeChangeEvent event) {
+    public void childrenChanged(@NotNull PsiTreeChangeEvent event) {
       doChange(event);
     }
 

platform/lang-impl/src/com/intellij/openapi/roots/impl/ProjectRootManagerImpl.java

@@ -730,7 +730,7 @@ public class ProjectRootManagerImpl extends ProjectRootManagerEx implements Proj
   }
 
   private class MyVirtualFilePointerListener implements VirtualFilePointerListener {
-    public void beforeValidityChanged(VirtualFilePointer[] pointers) {
+    public void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers) {
       if (!myProject.isDisposed()) {
         if (myInsideRefresh == 0) {
           if (affectsRoots(pointers)) {
@@ -747,7 +747,7 @@ public class ProjectRootManagerImpl extends ProjectRootManagerEx implements Proj
       }
     }
 
-    public void validityChanged(VirtualFilePointer[] pointers) {
+    public void validityChanged(@NotNull VirtualFilePointer[] pointers) {
       if (!myProject.isDisposed()) {
         if (myInsideRefresh > 0) {
           clearScopesCaches();

platform/lang-impl/src/com/intellij/profile/codeInspection/ui/InspectionToolsConfigurable.java

@@ -49,6 +49,7 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.profile.Profile;
+import com.intellij.profile.ProfileManager;
 import com.intellij.profile.codeInspection.InspectionProfileManager;
 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
 import com.intellij.ui.components.JBScrollPane;
@@ -99,7 +100,8 @@ public abstract class InspectionToolsConfigurable extends BaseConfigurable imple
     InspectionToolRegistrar.getInstance().buildInspectionSearchIndexIfNecessary();
     myAddButton.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent e) {
-        final ModifiableModel model = SingleInspectionProfilePanel.createNewProfile(-1, getSelectedObject(), myWholePanel, "");
+        final Set<String> existingProfileNames = myPanels.keySet();
+        final ModifiableModel model = SingleInspectionProfilePanel.createNewProfile(-1, getSelectedObject(), myWholePanel, "", existingProfileNames);
         if (model != null) {
           addProfile((InspectionProfileImpl)model);
           myDeletedProfiles.remove(model.getName());
@@ -113,7 +115,7 @@ public abstract class InspectionToolsConfigurable extends BaseConfigurable imple
         final InspectionProfileImpl selectedProfile = (InspectionProfileImpl)myProfiles.getSelectedItem();
         ((DefaultComboBoxModel)myProfiles.getModel()).removeElement(selectedProfile);
         myDeletedProfiles.add(selectedProfile.getName());
-        myDeleteButton.setEnabled(myProfiles.getModel().getSize() > 1);
+        myDeleteButton.setEnabled(isDeleteEnabled(selectedProfile));
       }
     });
 
@@ -216,7 +218,9 @@ public abstract class InspectionToolsConfigurable extends BaseConfigurable imple
 
     myCopyButton.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent e) {
-        final InspectionProfileImpl model = (InspectionProfileImpl)SingleInspectionProfilePanel.createNewProfile(0, getSelectedObject(), myWholePanel, "");
+        final Set<String> existingProfileNames = myPanels.keySet();
+        final InspectionProfileImpl model = (InspectionProfileImpl)
+          SingleInspectionProfilePanel.createNewProfile(0, getSelectedObject(), myWholePanel, "", existingProfileNames);
         if (model != null) {
           final InspectionProfileImpl modifiableModel = (InspectionProfileImpl)model.getModifiableModel();
           modifiableModel.setModified(true);
@@ -285,7 +289,7 @@ public abstract class InspectionToolsConfigurable extends BaseConfigurable imple
     myProfiles.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent e) {
         final InspectionProfileImpl profile = (InspectionProfileImpl)myProfiles.getSelectedItem();
-        myDeleteButton.setEnabled(myProfiles.getModel().getSize() > 1);
+        myDeleteButton.setEnabled(isDeleteEnabled(profile));
         myLayout.show(myPanel, profile.getName());
         SingleInspectionProfilePanel panel = getSelectedPanel();
         if (panel != null) {
@@ -352,7 +356,7 @@ public abstract class InspectionToolsConfigurable extends BaseConfigurable imple
     final InspectionProfileImpl inspectionProfile = getCurrentProfile();
     myProfiles.setSelectedItem(inspectionProfile);
     myLayout.show(myPanel, inspectionProfile.getName());
-    myDeleteButton.setEnabled(getProfiles().size() > 1 && inspectionProfile.getProfileManager() == myProfileManager);
+    myDeleteButton.setEnabled(isDeleteEnabled(inspectionProfile));
     final SingleInspectionProfilePanel panel = getSelectedPanel();
     if (panel != null) {
       panel.setVisible(true);//make sure that UI was initialized
@@ -373,6 +377,26 @@ public abstract class InspectionToolsConfigurable extends BaseConfigurable imple
     }
   }
 
+  private boolean isDeleteEnabled(InspectionProfileImpl inspectionProfile) {
+    final ProfileManager profileManager = inspectionProfile.getProfileManager();
+
+    boolean projectProfileFound = false;
+    boolean ideProfileFound = false;
+
+    final ComboBoxModel model = myProfiles.getModel();
+    for (int i = 0; i < model.getSize(); i++) {
+      Profile profile = (Profile)model.getElementAt(i);
+      if (inspectionProfile == profile) continue;
+      final boolean isProjectProfile = profile.getProfileManager() == myProjectProfileManager;
+      projectProfileFound |= isProjectProfile;
+      ideProfileFound |= !isProjectProfile;
+
+      if (ideProfileFound && projectProfileFound) break;
+    }
+
+    return profileManager == myProjectProfileManager ? projectProfileFound : ideProfileFound;
+  }
+  
   protected Collection<Profile> getProfiles() {
     final Collection<Profile> result = new ArrayList<Profile>();
     result.addAll(myProfileManager.getProfiles());

platform/lang-impl/src/com/intellij/profile/codeInspection/ui/SingleInspectionProfilePanel.java

@@ -59,7 +59,6 @@ import com.intellij.psi.search.scope.packageSet.NamedScope;
 import com.intellij.ui.*;
 import com.intellij.ui.treeStructure.Tree;
 import com.intellij.util.Alarm;
-import com.intellij.util.ArrayUtil;
 import com.intellij.util.config.StorageAccessors;
 import com.intellij.util.containers.Convertor;
 import com.intellij.util.ui.UIUtil;
@@ -262,12 +261,12 @@ public class SingleInspectionProfilePanel extends JPanel {
   public static ModifiableModel createNewProfile(final int initValue,
                                                  ModifiableModel selectedProfile,
                                                  JPanel parent,
-                                                 String profileName) {
-
+                                                 String profileName, 
+                                                 Set<String> existingProfileNames) {
     profileName = Messages.showInputDialog(parent, profileName, "Create New Inspection Profile", Messages.getQuestionIcon());
     if (profileName == null) return null;
     final ProfileManager profileManager = selectedProfile.getProfileManager();
-    if (ArrayUtil.find(profileManager.getAvailableProfileNames(), profileName) != -1) {
+    if (existingProfileNames.contains(profileName)) {
       Messages.showErrorDialog(InspectionsBundle.message("inspection.unable.to.create.profile.message", profileName),
                                InspectionsBundle.message("inspection.unable.to.create.profile.dialog.title"));
       return null;

platform/lang-impl/src/com/intellij/psi/impl/PsiToDocumentSynchronizer.java

@@ -104,7 +104,7 @@ public class PsiToDocumentSynchronizer extends PsiTreeChangeAdapter {
   }
 
   @Override
-  public void childAdded(final PsiTreeChangeEvent event) {
+  public void childAdded(@NotNull final PsiTreeChangeEvent event) {
     doSync(event, false, new DocSyncAction() {
       @Override
       public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
@@ -114,7 +114,7 @@ public class PsiToDocumentSynchronizer extends PsiTreeChangeAdapter {
   }
 
   @Override
-  public void childRemoved(final PsiTreeChangeEvent event) {
+  public void childRemoved(@NotNull final PsiTreeChangeEvent event) {
     doSync(event, false, new DocSyncAction() {
       @Override
       public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
@@ -124,7 +124,7 @@ public class PsiToDocumentSynchronizer extends PsiTreeChangeAdapter {
   }
 
   @Override
-  public void childReplaced(final PsiTreeChangeEvent event) {
+  public void childReplaced(@NotNull final PsiTreeChangeEvent event) {
     doSync(event, false, new DocSyncAction() {
       @Override
       public void syncDocument(Document document, PsiTreeChangeEventImpl event) {
@@ -134,7 +134,7 @@ public class PsiToDocumentSynchronizer extends PsiTreeChangeAdapter {
   }
 
   @Override
-  public void childrenChanged(final PsiTreeChangeEvent event) {
+  public void childrenChanged(@NotNull final PsiTreeChangeEvent event) {
     doSync(event, false, new DocSyncAction() {
       @Override
       public void syncDocument(Document document, PsiTreeChangeEventImpl event) {

platform/lang-impl/src/com/intellij/psi/stubs/StubIndexImpl.java

@@ -25,7 +25,6 @@ import com.intellij.openapi.application.ModalityState;
 import com.intellij.openapi.components.*;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.extensions.Extensions;
-import com.intellij.openapi.progress.ProgressManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -218,7 +217,6 @@ public class StubIndexImpl extends StubIndex implements ApplicationComponent, Pe
         return container.forEach(new ValueContainer.ContainerAction<TIntArrayList>() {
           @Override
           public boolean perform(final int id, @NotNull final TIntArrayList value) {
-            ProgressManager.checkCanceled();
             if (projectFilesFilter != null && !projectFilesFilter.contains(id)) return true;
             final VirtualFile file = IndexInfrastructure.findFileByIdIfCached(fs, id);
             if (file == null || scope != null && !scope.contains(file)) {

platform/lang-impl/src/com/intellij/refactoring/changeSignature/ChangeSignatureGestureDetector.java

@@ -160,7 +160,7 @@ public class ChangeSignatureGestureDetector extends PsiTreeChangeAdapter impleme
   }
 
   @Override
-  public void beforeChildRemoval(PsiTreeChangeEvent event) {
+  public void beforeChildRemoval(@NotNull PsiTreeChangeEvent event) {
     final PsiElement child = event.getChild();
     if (child instanceof PsiFile) {
       final PsiFile psiFile = (PsiFile)child;
@@ -177,17 +177,17 @@ public class ChangeSignatureGestureDetector extends PsiTreeChangeAdapter impleme
   }
 
   @Override
-  public void childRemoved(PsiTreeChangeEvent event) {
+  public void childRemoved(@NotNull PsiTreeChangeEvent event) {
     change(event.getParent());
   }
 
   @Override
-  public void childReplaced(PsiTreeChangeEvent event) {
+  public void childReplaced(@NotNull PsiTreeChangeEvent event) {
     change(event.getChild());
   }
 
   @Override
-  public void childAdded(PsiTreeChangeEvent event) {
+  public void childAdded(@NotNull PsiTreeChangeEvent event) {
     change(event.getChild());
   }
 

platform/lang-impl/src/com/intellij/refactoring/introduce/inplace/InplaceVariableIntroducer.java

@@ -17,6 +17,7 @@ package com.intellij.refactoring.introduce.inplace;
 
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.codeInsight.lookup.LookupElementBuilder;
+import com.intellij.codeInsight.template.ExpressionContext;
 import com.intellij.codeInsight.template.TextResult;
 import com.intellij.codeInsight.template.impl.TemplateManagerImpl;
 import com.intellij.codeInsight.template.impl.TemplateState;
@@ -33,10 +34,13 @@ import com.intellij.openapi.ui.popup.JBPopupFactory;
 import com.intellij.openapi.util.*;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiNamedElement;
+import com.intellij.psi.SmartPointerManager;
+import com.intellij.psi.SmartPsiElementPointer;
 import com.intellij.psi.codeStyle.SuggestedNameInfo;
 import com.intellij.refactoring.rename.NameSuggestionProvider;
 import com.intellij.refactoring.rename.PreferrableNameSuggestionProvider;
 import com.intellij.refactoring.rename.inplace.InplaceRefactoring;
+import com.intellij.refactoring.rename.inplace.MyLookupExpression;
 import com.intellij.ui.awt.RelativePoint;
 import com.intellij.util.ui.PositionTracker;
 import org.jetbrains.annotations.Nullable;
@@ -79,11 +83,6 @@ public abstract class InplaceVariableIntroducer<E extends PsiElement> extends In
     initOccurrencesMarkers();
   }
 
-  @Deprecated
-  public boolean performInplaceRename() {
-    return performInplaceRefactoring(null);
-  }
-  
   @Override
   protected boolean shouldSelectAll() {
     return true;
@@ -235,31 +234,61 @@ public abstract class InplaceVariableIntroducer<E extends PsiElement> extends In
   }
 
   @Override
-  protected LookupElement[] createLookupItems(LookupElement[] lookupItems, String name) {
-    TemplateState templateState = TemplateManagerImpl.getTemplateState(myEditor);
-    final PsiNamedElement psiVariable = getVariable();
-    if (psiVariable != null) {
-      final TextResult insertedValue =
-        templateState != null ? templateState.getVariableValue(PRIMARY_VARIABLE_NAME) : null;
-      if (insertedValue != null) {
-        final String text = insertedValue.getText();
-        if (!text.isEmpty() && !Comparing.strEqual(text, name)) {
-          final LinkedHashSet<String> names = new LinkedHashSet<String>();
-          names.add(text);
-          for (NameSuggestionProvider provider : Extensions.getExtensions(NameSuggestionProvider.EP_NAME)) {
-            final SuggestedNameInfo suggestedNameInfo = provider.getSuggestedNames(psiVariable, psiVariable, names);
-            if (suggestedNameInfo != null && provider instanceof PreferrableNameSuggestionProvider && !((PreferrableNameSuggestionProvider)provider).shouldCheckOthers()) break;
-          }
-          final LookupElement[] items = new LookupElement[names.size()];
-          final Iterator<String> iterator = names.iterator();
-          for (int i = 0; i < items.length; i++) {
-            items[i] = LookupElementBuilder.create(iterator.next());
-          }
-          return items;
-        }
-      }
-    }
-    return lookupItems;
+  protected MyLookupExpression createLookupExpression() {
+    return new MyIntroduceLookupExpression(getInitialName(), myNameSuggestions, myElementToRename, shouldSelectAll(), myAdvertisementText);
   }
 
+  private static class MyIntroduceLookupExpression extends MyLookupExpression {
+    private final SmartPsiElementPointer<PsiNamedElement> myPointer;
+
+    public MyIntroduceLookupExpression(final String initialName,
+                                       final LinkedHashSet<String> names,
+                                       final PsiNamedElement elementToRename,
+                                       final boolean shouldSelectAll,
+                                       final String advertisementText) {
+      super(initialName, names, elementToRename, shouldSelectAll, advertisementText);
+      myPointer = SmartPointerManager.getInstance(elementToRename.getProject()).createSmartPsiElementPointer(elementToRename);
+    }
+
+    @Override
+    public LookupElement[] calculateLookupItems(ExpressionContext context) {
+      return createLookupItems(myName, context.getEditor(), getElement());
+    }
+
+    @Nullable
+    public PsiNamedElement getElement() {
+      return myPointer.getElement();
+    }
+
+    @Nullable
+    private LookupElement[] createLookupItems(String name, Editor editor, PsiNamedElement psiVariable) {
+      TemplateState templateState = TemplateManagerImpl.getTemplateState(editor);
+      if (psiVariable != null) {
+        final TextResult insertedValue =
+          templateState != null ? templateState.getVariableValue(PRIMARY_VARIABLE_NAME) : null;
+        if (insertedValue != null) {
+          final String text = insertedValue.getText();
+          if (!text.isEmpty() && !Comparing.strEqual(text, name)) {
+            final LinkedHashSet<String> names = new LinkedHashSet<String>();
+            names.add(text);
+            for (NameSuggestionProvider provider : Extensions.getExtensions(NameSuggestionProvider.EP_NAME)) {
+              final SuggestedNameInfo suggestedNameInfo = provider.getSuggestedNames(psiVariable, psiVariable, names);
+              if (suggestedNameInfo != null &&
+                  provider instanceof PreferrableNameSuggestionProvider &&
+                  !((PreferrableNameSuggestionProvider)provider).shouldCheckOthers()) {
+                break;
+              }
+            }
+            final LookupElement[] items = new LookupElement[names.size()];
+            final Iterator<String> iterator = names.iterator();
+            for (int i = 0; i < items.length; i++) {
+              items[i] = LookupElementBuilder.create(iterator.next());
+            }
+            return items;
+          }
+        }
+      }
+      return myLookupItems;
+    }
+  }
 }

platform/lang-impl/src/com/intellij/refactoring/rename/inplace/InplaceRefactoring.java

@@ -15,13 +15,9 @@
  */
 package com.intellij.refactoring.rename.inplace;
 
-import com.intellij.codeInsight.completion.InsertHandler;
-import com.intellij.codeInsight.completion.InsertionContext;
 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
 import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerImpl;
 import com.intellij.codeInsight.highlighting.HighlightManager;
-import com.intellij.codeInsight.lookup.LookupElement;
-import com.intellij.codeInsight.lookup.LookupElementBuilder;
 import com.intellij.codeInsight.lookup.LookupManager;
 import com.intellij.codeInsight.lookup.impl.LookupImpl;
 import com.intellij.codeInsight.template.*;
@@ -43,7 +39,6 @@ import com.intellij.openapi.editor.colors.EditorColorsManager;
 import com.intellij.openapi.editor.impl.EditorImpl;
 import com.intellij.openapi.editor.markup.RangeHighlighter;
 import com.intellij.openapi.editor.markup.TextAttributes;
-import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.fileEditor.FileEditor;
 import com.intellij.openapi.fileEditor.FileEditorManager;
 import com.intellij.openapi.fileEditor.OpenFileDescriptor;
@@ -60,7 +55,6 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
-import com.intellij.psi.codeStyle.SuggestedNameInfo;
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
 import com.intellij.psi.search.LocalSearchScope;
 import com.intellij.psi.search.ProjectScope;
@@ -68,8 +62,6 @@ import com.intellij.psi.search.PsiSearchHelper;
 import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.search.searches.ReferencesSearch;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.refactoring.rename.NameSuggestionProvider;
-import com.intellij.refactoring.rename.PreferrableNameSuggestionProvider;
 import com.intellij.refactoring.util.CommonRefactoringUtil;
 import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NonNls;
@@ -93,7 +85,7 @@ public abstract class InplaceRefactoring {
   protected final Editor myEditor;
   protected final Project myProject;
   protected RangeMarker myRenameOffset;
-  private String myAdvertisementText;
+  protected String myAdvertisementText;
   private ArrayList<RangeHighlighter> myHighlighters;
   protected String myInitialName;
   protected final String myOldName;
@@ -205,7 +197,9 @@ public abstract class InplaceRefactoring {
 
   protected abstract boolean shouldSelectAll();
 
-  protected abstract LookupElement[] createLookupItems(LookupElement[] lookupItems, String name);
+  protected MyLookupExpression createLookupExpression() {
+    return new MyLookupExpression(getInitialName(), myNameSuggestions, myElementToRename, shouldSelectAll(), myAdvertisementText);
+  }
 
   protected Collection<PsiReference> collectRefs(SearchScope referencesSearchScope) {
     return ReferencesSearch.search(myElementToRename, referencesSearchScope, false).findAll();
@@ -536,8 +530,7 @@ public abstract class InplaceRefactoring {
                            int offset) {
     if (reference.getElement() == selectedElement &&
         contains(reference.getRangeInElement().shiftRight(selectedElement.getTextRange().getStartOffset()), offset)) {
-      Expression expression = new MyExpression(getInitialName(), myNameSuggestions);
-      builder.replaceElement(reference, PRIMARY_VARIABLE_NAME, expression, true);
+      builder.replaceElement(reference, PRIMARY_VARIABLE_NAME, createLookupExpression(), true);
     }
     else {
       builder.replaceElement(reference, OTHER_VARIABLE_NAME, PRIMARY_VARIABLE_NAME, false);
@@ -555,8 +548,7 @@ public abstract class InplaceRefactoring {
                            final PsiElement selectedElement,
                            final TemplateBuilderImpl builder) {
     if (element == selectedElement) {
-      Expression expression = new MyExpression(getInitialName(), myNameSuggestions);
-      builder.replaceElement(element, PRIMARY_VARIABLE_NAME, expression, true);
+      builder.replaceElement(element, PRIMARY_VARIABLE_NAME, createLookupExpression(), true);
     }
     else if (textRange != null) {
       builder.replaceElement(element, textRange, OTHER_VARIABLE_NAME, PRIMARY_VARIABLE_NAME, false);
@@ -614,63 +606,6 @@ public abstract class InplaceRefactoring {
     return range.getStartOffset() <= offset && offset <= range.getEndOffset();
   }
 
-  protected class MyExpression extends Expression {
-    private final String myName;
-    private final LookupElement[] myLookupItems;
-
-    protected MyExpression(String name, LinkedHashSet<String> names) {
-      myName = name;
-      if (names == null) {
-        names = new LinkedHashSet<String>();
-        for (NameSuggestionProvider provider : Extensions.getExtensions(NameSuggestionProvider.EP_NAME)) {
-          final SuggestedNameInfo suggestedNameInfo = provider.getSuggestedNames(myElementToRename, myElementToRename, names);
-          if (suggestedNameInfo != null && provider instanceof PreferrableNameSuggestionProvider && !((PreferrableNameSuggestionProvider)provider).shouldCheckOthers()) break;
-        }
-      }
-      myLookupItems = new LookupElement[names.size()];
-      final Iterator<String> iterator = names.iterator();
-      for (int i = 0; i < myLookupItems.length; i++) {
-        final String suggestion = iterator.next();
-        myLookupItems[i] = LookupElementBuilder.create(suggestion).setInsertHandler(new InsertHandler<LookupElement>() {
-          @Override
-          public void handleInsert(InsertionContext context, LookupElement item) {
-            if (shouldSelectAll()) return;
-            final Editor topLevelEditor = InjectedLanguageUtil.getTopLevelEditor(myEditor);
-            final TemplateState templateState = TemplateManagerImpl.getTemplateState(topLevelEditor);
-            if (templateState != null) {
-              final TextRange range = templateState.getCurrentVariableRange();
-              if (range != null) {
-                topLevelEditor.getDocument().replaceString(range.getStartOffset(), range.getEndOffset(), suggestion);
-              }
-            }
-          }
-        });
-      }
-    }
-
-    public LookupElement[] calculateLookupItems(ExpressionContext context) {
-      return createLookupItems(myLookupItems, myName);
-    }
-
-    public Result calculateQuickResult(ExpressionContext context) {
-      return calculateResult(context);
-    }
-
-    public Result calculateResult(ExpressionContext context) {
-      TemplateState templateState = TemplateManagerImpl.getTemplateState(myEditor);
-      final TextResult insertedValue = templateState != null ? templateState.getVariableValue(PRIMARY_VARIABLE_NAME) : null;
-      if (insertedValue != null) {
-        if (!insertedValue.getText().isEmpty()) return insertedValue;
-      }
-      return new TextResult(myName);
-    }
-
-    @Override
-    public String getAdvertisingText() {
-      return myAdvertisementText;
-    }
-  }
-
   private abstract class MyTemplateListener extends TemplateEditingAdapter {
 
     protected abstract void restoreDaemonUpdateState();

platform/lang-impl/src/com/intellij/refactoring/rename/inplace/MemberInplaceRenameHandler.java

@@ -16,15 +16,19 @@
 package com.intellij.refactoring.rename.inplace;
 
 import com.intellij.codeInsight.lookup.LookupManager;
+import com.intellij.codeInsight.template.impl.TemplateManagerImpl;
+import com.intellij.codeInsight.template.impl.TemplateState;
 import com.intellij.lang.LanguageRefactoringSupport;
 import com.intellij.lang.refactoring.RefactoringSupportProvider;
 import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.openapi.command.impl.StartMarkAction;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.util.Pass;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiNameIdentifierOwner;
 import com.intellij.psi.PsiNamedElement;
+import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.rename.RenamePsiElementProcessor;
 import org.jetbrains.annotations.NotNull;
@@ -52,17 +56,29 @@ public class MemberInplaceRenameHandler extends VariableInplaceRenameHandler {
     if (elementToRename instanceof PsiNameIdentifierOwner) {
       final RenamePsiElementProcessor processor = RenamePsiElementProcessor.forElement(elementToRename);
       if (processor.isInplaceRenameSupported()) {
-        processor.substituteElementToRename(elementToRename, editor, new Pass<PsiElement>() {
-          @Override
-          public void pass(PsiElement element) {
-            final MemberInplaceRenamer renamer = new MemberInplaceRenamer((PsiNameIdentifierOwner)elementToRename, element, editor);
-            boolean startedRename = renamer.performInplaceRename();
-            if (!startedRename) {
-              performDialogRename(elementToRename, editor, dataContext);
+        final StartMarkAction startMarkAction = StartMarkAction.canStart(elementToRename.getProject());
+        if (startMarkAction == null) {
+          processor.substituteElementToRename(elementToRename, editor, new Pass<PsiElement>() {
+            @Override
+            public void pass(PsiElement element) {
+              final MemberInplaceRenamer renamer = new MemberInplaceRenamer((PsiNameIdentifierOwner)elementToRename, element, editor);
+              boolean startedRename = renamer.performInplaceRename();
+              if (!startedRename) {
+                performDialogRename(elementToRename, editor, dataContext);
+              }
+            }
+          });
+          return null;
+        }
+        else {
+          final InplaceRefactoring inplaceRefactoring = editor.getUserData(InplaceRefactoring.INPLACE_RENAMER);
+          if (inplaceRefactoring != null && inplaceRefactoring.getClass() == MemberInplaceRenamer.class) {
+            final TemplateState templateState = TemplateManagerImpl.getTemplateState(InjectedLanguageUtil.getTopLevelEditor(editor));
+            if (templateState != null) {
+              templateState.gotoEnd(true);
             }
           }
-        });
-        return null;
+        }
       }
     }
     performDialogRename(elementToRename, editor, dataContext);

platform/lang-impl/src/com/intellij/refactoring/rename/inplace/MemberInplaceRenamer.java

@@ -233,12 +233,9 @@ public class MemberInplaceRenamer extends VariableInplaceRenamer {
   }
 
   @Override
-  public void finish(boolean success) {
-    super.finish(success);
-    if (success) {
-      ((EditorImpl)InjectedLanguageUtil.getTopLevelEditor(myEditor)).startDumb();
-      revertState();
-    }
+  protected void revertStateOnFinish() {
+    ((EditorImpl)InjectedLanguageUtil.getTopLevelEditor(myEditor)).startDumb();
+    revertState();
   }
 
   @Nullable

platform/lang-impl/src/com/intellij/refactoring/rename/inplace/MyLookupExpression.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2000-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.refactoring.rename.inplace;
+
+import com.intellij.codeInsight.completion.InsertHandler;
+import com.intellij.codeInsight.completion.InsertionContext;
+import com.intellij.codeInsight.lookup.LookupElement;
+import com.intellij.codeInsight.lookup.LookupElementBuilder;
+import com.intellij.codeInsight.template.Expression;
+import com.intellij.codeInsight.template.ExpressionContext;
+import com.intellij.codeInsight.template.Result;
+import com.intellij.codeInsight.template.TextResult;
+import com.intellij.codeInsight.template.impl.TemplateManagerImpl;
+import com.intellij.codeInsight.template.impl.TemplateState;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiNamedElement;
+import com.intellij.psi.codeStyle.SuggestedNameInfo;
+import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
+import com.intellij.refactoring.rename.NameSuggestionProvider;
+import com.intellij.refactoring.rename.PreferrableNameSuggestionProvider;
+
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+
+/**
+* User: anna
+* Date: 3/16/12
+*/
+public class MyLookupExpression extends Expression {
+  protected final String myName;
+  protected final LookupElement[] myLookupItems;
+  private final String myAdvertisementText;
+
+  public MyLookupExpression(final String name,
+                            final LinkedHashSet<String> names,
+                            final PsiNamedElement elementToRename,
+                            final boolean shouldSelectAll,
+                            final String advertisement) {
+    myName = name;
+    myAdvertisementText = advertisement;
+    myLookupItems = initLookupItems(names, elementToRename, shouldSelectAll);
+  }
+
+  private static LookupElement[] initLookupItems(LinkedHashSet<String> names,
+                                                 PsiNamedElement elementToRename,
+                                                 final boolean shouldSelectAll) {
+    if (names == null) {
+      names = new LinkedHashSet<String>();
+      for (NameSuggestionProvider provider : Extensions.getExtensions(NameSuggestionProvider.EP_NAME)) {
+        final SuggestedNameInfo suggestedNameInfo = provider.getSuggestedNames(elementToRename, elementToRename, names);
+        if (suggestedNameInfo != null &&
+            provider instanceof PreferrableNameSuggestionProvider &&
+            !((PreferrableNameSuggestionProvider)provider).shouldCheckOthers()) {
+          break;
+        }
+      }
+    }
+    final LookupElement[] lookupElements = new LookupElement[names.size()];
+    final Iterator<String> iterator = names.iterator();
+    for (int i = 0; i < lookupElements.length; i++) {
+      final String suggestion = iterator.next();
+      lookupElements[i] = LookupElementBuilder.create(suggestion).setInsertHandler(new InsertHandler<LookupElement>() {
+        @Override
+        public void handleInsert(InsertionContext context, LookupElement item) {
+          if (shouldSelectAll) return;
+          final Editor topLevelEditor = InjectedLanguageUtil.getTopLevelEditor(context.getEditor());
+          final TemplateState templateState = TemplateManagerImpl.getTemplateState(topLevelEditor);
+          if (templateState != null) {
+            final TextRange range = templateState.getCurrentVariableRange();
+            if (range != null) {
+              topLevelEditor.getDocument().replaceString(range.getStartOffset(), range.getEndOffset(), suggestion);
+            }
+          }
+        }
+      });
+    }
+    return lookupElements;
+  }
+
+  public LookupElement[] calculateLookupItems(ExpressionContext context) {
+    return myLookupItems;
+  }
+
+  public Result calculateQuickResult(ExpressionContext context) {
+    return calculateResult(context);
+  }
+
+  public Result calculateResult(ExpressionContext context) {
+    TemplateState templateState = TemplateManagerImpl.getTemplateState(context.getEditor());
+    final TextResult insertedValue = templateState != null ? templateState.getVariableValue(InplaceRefactoring.PRIMARY_VARIABLE_NAME) : null;
+    if (insertedValue != null) {
+      if (!insertedValue.getText().isEmpty()) return insertedValue;
+    }
+    return new TextResult(myName);
+  }
+
+  @Override
+  public String getAdvertisingText() {
+    return myAdvertisementText;
+  }
+}

platform/lang-impl/src/com/intellij/refactoring/rename/inplace/VariableInplaceRenamer.java

@@ -15,7 +15,6 @@
  */
 package com.intellij.refactoring.rename.inplace;
 
-import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.lang.Language;
 import com.intellij.lang.LanguageExtension;
 import com.intellij.lang.LanguageNamesValidation;
@@ -192,6 +191,9 @@ public class VariableInplaceRenamer extends InplaceRefactoring {
   protected void performRefactoringRename(final String newName,
                                           final StartMarkAction markAction) {
     try {
+      if (!isIdentifier(newName)) {
+        return;
+      }
       PsiNamedElement elementToRename = getVariable();
       if (elementToRename != null) {
         new WriteCommandAction(myProject, getCommandName()) {
@@ -288,14 +290,26 @@ public class VariableInplaceRenamer extends InplaceRefactoring {
     return bind;
   }
 
+  @Override
+  public void finish(boolean success) {
+    super.finish(success);
+    if (success) {
+      revertStateOnFinish();
+    }
+    else {
+      ((EditorImpl)InjectedLanguageUtil.getTopLevelEditor(myEditor)).stopDumb();
+    }
+  }
+
+  protected void revertStateOnFinish() {
+    if (!isIdentifier(myInsertedName)) {
+      revertState();
+    }
+  }
+
   private boolean isIdentifier(final String newName) {
 
     final NamesValidator namesValidator = LanguageNamesValidation.INSTANCE.forLanguage(myLanguage);
     return namesValidator == null || namesValidator.isIdentifier(newName, myProject);
   }
-
-  @Override
-  protected LookupElement[] createLookupItems(final LookupElement[] lookupItems, final String name) {
-    return lookupItems;
-  }
 }

platform/lang-impl/src/com/intellij/util/indexing/ChangeTrackingValueContainer.java

@@ -139,9 +139,9 @@ class ChangeTrackingValueContainer<Value> extends UpdatableValueContainer<Value>
       final ValueContainerImpl<Value> newMerged;
 
       if (fromDisk instanceof ValueContainerImpl) {
-        newMerged = ((ValueContainerImpl<Value>)fromDisk).clone();
+        newMerged = ((ValueContainerImpl<Value>)fromDisk).copy();
       } else {
-        newMerged = ((ChangeTrackingValueContainer<Value>)fromDisk).getMergedData().clone();
+        newMerged = ((ChangeTrackingValueContainer<Value>)fromDisk).getMergedData().copy();
       }
       myInvalidated.forEach(new TIntProcedure() {
         @Override

platform/lang-impl/src/com/intellij/util/indexing/ValueContainerImpl.java

@@ -234,6 +234,22 @@ class ValueContainerImpl<Value> extends UpdatableValueContainer<Value> implement
     }
   };
 
+  public ValueContainerImpl<Value> copy() {
+    final ValueContainerImpl<Value> container = new ValueContainerImpl<Value>();
+    myInputIdMapping.forEachEntry(new TObjectObjectProcedure<Value, Object>() {
+      @Override
+      public boolean execute(Value key, Object val) {
+        if (val instanceof TIntHashSet) {
+          container.myInputIdMapping.put(key, ((TIntHashSet)val).clone());
+        } else {
+          container.myInputIdMapping.put(key, val);
+        }
+        return true;
+      }
+    });
+    return container;
+  }
+
   private static class SingleValueIterator implements IntIterator {
     private final int myValue;
     private boolean myValueRead = false;

platform/platform-api/src/com/intellij/ide/ui/UISettings.java

@@ -28,7 +28,6 @@ import com.intellij.openapi.components.Storage;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.SystemInfo;
 import com.intellij.util.PlatformUtils;
-import com.intellij.util.ui.GraphicsUtil;
 import com.intellij.util.xmlb.Accessor;
 import com.intellij.util.xmlb.SerializationFilter;
 import com.intellij.util.xmlb.XmlSerializerUtil;
@@ -300,7 +299,25 @@ public class UISettings implements PersistentStateComponent<UISettings>, Exporta
     UISettings uiSettings=getInstance();
 
     g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_OFF);
-    GraphicsUtil.setupAntialiasing(g2d, uiSettings == null || uiSettings.ANTIALIASING_IN_EDITOR, true);
+    if (uiSettings == null || uiSettings.ANTIALIASING_IN_EDITOR) {
+      Toolkit tk = Toolkit.getDefaultToolkit();
+      //noinspection HardCodedStringLiteral
+      Map map = (Map)tk.getDesktopProperty("awt.font.desktophints");
+      if (map != null) {
+        if (isRemoteDesktopConnected()) {
+          g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);
+        }
+        else {
+          g2d.addRenderingHints(map);
+        }
+      }
+      else {
+        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+      }
+    }
+    else {
+      g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+    }
   }
 
   /**

platform/platform-api/src/com/intellij/openapi/actionSystem/ActionButtonComponent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,12 +15,18 @@
  */
 package com.intellij.openapi.actionSystem;
 
+import org.intellij.lang.annotations.MagicConstant;
+
 public interface ActionButtonComponent {
   int NORMAL = 0;
   int POPPED = 1;
   int PUSHED = -1;
   int SELECTED = 2;
 
+  @MagicConstant(flags = {NORMAL, POPPED, PUSHED, SELECTED})
+  @interface ButtonState { }
+
+  @ButtonState
   int getPopState();
 
   int getWidth();

platform/platform-api/src/com/intellij/openapi/vfs/pointers/VirtualFilePointerListener.java

@@ -16,10 +16,11 @@
 package com.intellij.openapi.vfs.pointers;
 
 import com.intellij.util.messages.Topic;
+import org.jetbrains.annotations.NotNull;
 
 public interface VirtualFilePointerListener {
   Topic<VirtualFilePointerListener> TOPIC = Topic.create("VirtualFilePointer", VirtualFilePointerListener.class);
 
-  void beforeValidityChanged(VirtualFilePointer[] pointers);
-  void validityChanged(VirtualFilePointer[] pointers);
+  void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers);
+  void validityChanged(@NotNull VirtualFilePointer[] pointers);
 }

platform/platform-api/src/com/intellij/ui/components/JBOptionButton.java

@@ -53,11 +53,7 @@ public class JBOptionButton extends JButton implements MouseMotionListener {
   private boolean myOkToProcessDefaultMnemonics = true;
 
   private IdeGlassPane myGlassPane;
-  private final Disposable myDisposable = new Disposable() {
-    @Override
-    public void dispose() {
-    }
-  };
+  private final Disposable myDisposable = Disposer.newDisposable();
 
   public JBOptionButton(Action action, Action[] options) {
     super(action);

platform/platform-api/src/com/intellij/ui/switcher/SwitchingSession.java

@@ -76,11 +76,7 @@ public class SwitchingSession implements KeyEventDispatcher, Disposable {
   };
 
   private boolean myFadingAway;
-  private Disposable myPainterDisposable = new Disposable() {
-    @Override
-    public void dispose() {
-    }
-  };
+  private Disposable myPainterDisposable = Disposer.newDisposable();
 
   public SwitchingSession(SwitchManager mgr, SwitchProvider provider, KeyEvent e, @Nullable SwitchTarget preselected, boolean showSpots) {
     myManager = mgr;

platform/platform-api/src/com/intellij/util/PathUtil.java

@@ -25,8 +25,6 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.io.File;
-
 public class PathUtil {
   private PathUtil() {
   }
@@ -63,8 +61,9 @@ public class PathUtil {
 
   @NotNull
   public static String getJarPathForClass(@NotNull Class aClass) {
-    String resourceRoot = PathManager.getResourceRoot(aClass, "/" + aClass.getName().replace('.', '/') + ".class");
-    return new File(resourceRoot).getAbsoluteFile().getAbsolutePath();
+    final String pathForClass = PathManager.getJarPathForClass(aClass);
+    assert pathForClass != null : aClass;
+    return pathForClass;
   }
 
   @NotNull

platform/platform-impl/src/com/intellij/help/impl/IdeaJHelp.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2011 JetBrains s.r.o.
+ * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
  */
 package com.intellij.help.impl;
 
-import com.intellij.ide.ui.UISettings;
+import com.intellij.util.ui.GraphicsUtil;
 
 import javax.help.DefaultHelpModel;
 import javax.help.HelpSet;
@@ -53,7 +53,7 @@ class IdeaJHelp extends JHelp{
 
   @Override
   public void paint(Graphics g) {
-    UISettings.setupAntialiasing(g);
+    GraphicsUtil.setupAntialiasing(g);
     super.paint(g);
   }
 }

platform/platform-impl/src/com/intellij/ide/plugins/ActionInstallPlugin.java

@@ -47,6 +47,8 @@ import java.util.*;
 public class ActionInstallPlugin extends AnAction implements DumbAware {
   final private static String updateMessage = IdeBundle.message("action.update.plugin");
 
+  private static final Set<IdeaPluginDescriptor> ourInstallingNodes = new HashSet<IdeaPluginDescriptor>();
+
   private final PluginManagerMain installed;
   private final PluginManagerMain host;
 
@@ -65,6 +67,7 @@ public class ActionInstallPlugin extends AnAction implements DumbAware {
       for (IdeaPluginDescriptor descr : selection) {
         presentation.setText(IdeBundle.message("action.download.and.install.plugin"));
         presentation.setDescription(IdeBundle.message("action.download.and.install.plugin"));
+        enabled &= !ourInstallingNodes.contains(descr);
         if (descr instanceof PluginNode) {
           enabled &= !PluginManagerColumnInfo.isDownloaded((PluginNode)descr);
           if (((PluginNode)descr).getStatus() == PluginNode.STATUS_INSTALLED) {
@@ -108,6 +111,7 @@ public class ActionInstallPlugin extends AnAction implements DumbAware {
 
         if (pluginNode != null) {
           list.add(pluginNode);
+          ourInstallingNodes.add(pluginNode);
         }
       }
       try {
@@ -143,7 +147,12 @@ public class ActionInstallPlugin extends AnAction implements DumbAware {
             }
           }
         };
-        PluginManagerMain.downloadPlugins(list, host.getPluginsModel().view, onInstallRunnable);
+        PluginManagerMain.downloadPlugins(list, host.getPluginsModel().view, onInstallRunnable, new Runnable(){
+          @Override
+          public void run() {
+            ourInstallingNodes.removeAll(list);
+          }
+        });
       }
       catch (IOException e1) {
         PluginManagerMain.LOG.error(e1);

platform/platform-impl/src/com/intellij/ide/plugins/InstalledPluginsManagerMain.java

@@ -116,7 +116,9 @@ public class InstalledPluginsManagerMain extends PluginManagerMain {
     final Set<PluginId> notInstalled = new HashSet<PluginId>();
     final Set<PluginId> disabledIds = new HashSet<PluginId>();
     final PluginId[] dependentPluginIds = pluginDescriptor.getDependentPluginIds();
+    final PluginId[] optionalDependentPluginIds = pluginDescriptor.getOptionalDependentPluginIds();
     for (PluginId id : dependentPluginIds) {
+      if (Arrays.binarySearch(optionalDependentPluginIds, id) > -1) continue;
       final boolean disabled = ((InstalledPluginsTableModel)pluginsModel).isDisabled(id);
       final boolean enabled = ((InstalledPluginsTableModel)pluginsModel).isEnabled(id);
       if (!enabled && !disabled && !PluginManager.isModuleDependency(id)) {

platform/platform-impl/src/com/intellij/ide/plugins/PluginManagerMain.java

@@ -288,7 +288,10 @@ public abstract class PluginManagerMain implements Disposable {
     loadPluginsFromHostInBackground();
   }
 
-  public static boolean downloadPlugins(final List<PluginNode> plugins, final List<IdeaPluginDescriptor> allPlugins, final Runnable onSuccess) throws IOException {
+  public static boolean downloadPlugins(final List<PluginNode> plugins,
+                                        final List<IdeaPluginDescriptor> allPlugins,
+                                        final Runnable onSuccess,
+                                        final Runnable cleanup) throws IOException {
     final boolean[] result = new boolean[1];
     try {
       ProgressManager.getInstance().run(new Task.Backgroundable(null, IdeBundle.message("progress.download.plugins"), true) {
@@ -299,6 +302,18 @@ public abstract class PluginManagerMain implements Disposable {
             result[0] = true;
           }
         }
+
+        @Override
+        public void onCancel() {
+          cleanup.run();
+          super.onCancel();
+        }
+
+        @Override
+        public void onSuccess() {
+          super.onSuccess();
+          cleanup.run();
+        }
       });
     }
     catch (RuntimeException e) {

platform/platform-impl/src/com/intellij/openapi/actionSystem/ex/ActionButtonLook.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2009 JetBrains s.r.o.
+ * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,12 +32,14 @@ public abstract class ActionButtonLook {
     paintBorder(g, button, getState(button));
   }
 
-  public abstract void paintBackground(Graphics g, JComponent component, int state);
+  public abstract void paintBackground(Graphics g, JComponent component, @ActionButtonComponent.ButtonState int state);
 
-  public abstract void paintBorder(Graphics g, JComponent component, int state);
+  public abstract void paintBorder(Graphics g, JComponent component, @ActionButtonComponent.ButtonState int state);
 
-  protected int getState(ActionButtonComponent button) { // Do NOT inline this method.
-    // Because of compiler bug upcast from ButtonType to ActionButtonComponent is important
+  @SuppressWarnings("MethodMayBeStatic")
+  @ActionButtonComponent.ButtonState
+  protected int getState(ActionButtonComponent button) {
+    // DO NOT inline this method! Because of compiler bug up-cast from ButtonType to ActionButtonComponent is important!
     return button.getPopState();
   }