Merge remote-tracking branch 'origin/master'

2026-09-27 10:03:11 +07:00 · 2012-05-29 20:58:46 +04:00
parent ba2d5beff8 644f381a9e
commit d0ba5f2ffd
18 changed files with 318 additions and 72 deletions
@@ -148,7 +148,8 @@ public class JavaCompletionData extends JavaAwareCompletionData{
      not(
        or(psiElement(PsiTypeCastExpression.class),
           psiElement(PsiSwitchLabelStatement.class),
-           psiElement(PsiExpressionStatement.class)
+           psiElement(PsiExpressionStatement.class),
+           psiElement(PsiPrefixExpression.class)
        )
      )
    )),
@@ -689,8 +689,15 @@ public class HighlightClassUtil {
      return null;
    }
    final PsiClass aClass = (PsiClass)grand;
+    final PsiClass containerClass;
    if (aClass instanceof PsiTypeParameter) {
-      return null;
+      final PsiTypeParameterListOwner owner = ((PsiTypeParameter)aClass).getOwner();
+      if (!(owner instanceof PsiClass)) {
+        return null;
+      }
+      containerClass = (PsiClass)owner;
+    } else {
+      containerClass = aClass;
    }
    if (aClass.getExtendsList() != parent && aClass.getImplementsList() != parent) {
      return null;
@@ -713,7 +720,7 @@ public class HighlightClassUtil {
        if (resolve instanceof PsiClass) {
          final PsiClass base = (PsiClass)resolve;
          final PsiClass baseClass = base.getContainingClass();
-          if (baseClass != null && base.hasModifierProperty(PsiModifier.PRIVATE) && !PsiTreeUtil.isAncestor(baseClass, aClass, true)) {
+          if (baseClass != null && base.hasModifierProperty(PsiModifier.PRIVATE) && baseClass == containerClass) {
            String description = JavaErrorMessages.message("private.symbol",
                                                           HighlightUtil.formatClass(base),
                                                           HighlightUtil.formatClass(baseClass));
@@ -628,6 +628,7 @@ public class PsiClassImplUtil {
                                           PsiElement place,
                                           ResolveState state,
                                           boolean isRaw, PsiElementFactory factory) {
+    boolean resolved = false;
    for (final PsiClassType superType : aClass.getSuperTypes()) {
      final PsiClassType.ClassResolveResult superTypeResolveResult = superType.resolveGenerics();
      PsiClass superClass = superTypeResolveResult.getElement();
@@ -635,10 +636,10 @@ public class PsiClassImplUtil {
      PsiSubstitutor finalSubstitutor = obtainFinalSubstitutor(superClass, superTypeResolveResult.getSubstitutor(), aClass, state.get(PsiSubstitutor.KEY),
                                                               place, factory);
      if (!processDeclarationsInClass(superClass, processor, state.put(PsiSubstitutor.KEY, finalSubstitutor), visited, last, place, isRaw)) {
-        return false;
+        resolved = true;
      }
    }
-    return true;
+    return !resolved;
  }

  @Nullable
@@ -15,17 +15,15 @@
 */
 package com.intellij.psi.impl.source.resolve;

+import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.PsiImplUtil;
 import com.intellij.psi.infos.CandidateInfo;
 import com.intellij.psi.infos.ClassCandidateInfo;
-import com.intellij.psi.scope.BaseScopeProcessor;
-import com.intellij.psi.scope.ElementClassHint;
-import com.intellij.psi.scope.JavaScopeProcessorEvent;
-import com.intellij.psi.scope.NameHint;
-import com.intellij.psi.scope.PsiScopeProcessor;
+import com.intellij.psi.scope.*;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.SmartList;

 import java.util.Iterator;
@@ -49,15 +47,21 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi
      if (((JavaCodeFragment)file).getVisibilityChecker() != null) place = null;
    }
    myPlace = place;
-    if (place instanceof PsiReferenceExpression) {
-      final PsiReferenceExpression expression = (PsiReferenceExpression)place;
-      final PsiExpression qualifierExpression = expression.getQualifierExpression();
-      if (qualifierExpression != null) {
-        final PsiType type = qualifierExpression.getType();
+    if (place instanceof PsiJavaCodeReferenceElement) {
+      final PsiJavaCodeReferenceElement expression = (PsiJavaCodeReferenceElement)place;
+      final PsiElement qualifierExpression = expression.getQualifier();
+      if (qualifierExpression instanceof PsiExpression) {
+        final PsiType type = ((PsiExpression)qualifierExpression).getType();
        if (type instanceof PsiClassType) {
          myAccessClass = ((PsiClassType)type).resolve();
        }
      }
+      else if (qualifierExpression instanceof PsiJavaCodeReferenceElement) {
+        final PsiElement resolve = ((PsiJavaCodeReferenceElement)qualifierExpression).resolve();
+        if (resolve instanceof PsiClass) {
+          myAccessClass = (PsiClass)resolve;
+        }
+      }
    }
  }

@@ -132,13 +136,23 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi

    final PsiClass containingClass1 = aClass.getContainingClass();
    final PsiClass containingClass2 = otherClass.getContainingClass();
-    if (containingClass1 != null && containingClass2 != null && containingClass2.isInheritor(containingClass1, true) &&
-        !isImported(myCurrentFileContext)) {
-      // shadowing
-      return Domination.DOMINATED_BY;
+    if (myAccessClass != null && !Comparing.equal(containingClass1, containingClass2)) {
+      if (myAccessClass.equals(containingClass1)) return Domination.DOMINATES;
+      if (myAccessClass.equals(containingClass2)) return Domination.DOMINATED_BY;
    }

-    boolean infoAccessible = info.isAccessible();
+    //JLS 8.5:
+    //A class may inherit two or more type declarations with the same name, either from two interfaces or from its superclass and an interface. 
+    //It is a compile-time error to attempt to refer to any ambiguously inherited class or interface by its simple name.
+    if (containingClass1 != null && containingClass2 != null && containingClass2.isInheritor(containingClass1, true) &&
+        !isImported(myCurrentFileContext)) {
+      if (!isAmbiguousInherited(containingClass1)) {
+        // shadowing
+        return Domination.DOMINATED_BY;
+      }
+    }
+
+    boolean infoAccessible = info.isAccessible() && !otherClass.hasModifierProperty(PsiModifier.PRIVATE);
    if (infoAccessible && !accessible) {
      return Domination.DOMINATED_BY;
    }
@@ -169,6 +183,17 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi
    return Domination.EQUAL;
  }

+  private boolean isAmbiguousInherited(PsiClass containingClass1) {
+    PsiClass psiClass = PsiTreeUtil.getParentOfType(myPlace, PsiClass.class);
+    while (psiClass != null) {
+      if (psiClass.isInheritor(containingClass1, false)) {
+        return true;
+      }
+      psiClass = psiClass.getContainingClass();
+    }
+    return false;
+  }
+
  @Override
  public boolean execute(PsiElement element, ResolveState state) {
    if (!(element instanceof PsiClass)) return true;
@@ -187,7 +212,7 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi
        for (int i = myCandidates.size()-1; i>=0; i--) {
          ClassCandidateInfo info = myCandidates.get(i);

-          Domination domination = dominates(aClass, accessible, fqName, info);
+          Domination domination = dominates(aClass, accessible && !aClass.hasModifierProperty(PsiModifier.PRIVATE), fqName, info);
          if (domination == Domination.DOMINATED_BY) {
            return true;
          }
@@ -202,7 +227,7 @@ public class ClassResolverProcessor extends BaseScopeProcessor implements NameHi
    myHasInaccessibleCandidate |= !accessible;
    myCandidates.add(new ClassCandidateInfo(aClass, state.get(PsiSubstitutor.KEY), !accessible, myCurrentFileContext));
    myResult = null;
-    if (!accessible) return true;
+    if (!accessible || aClass.hasModifierProperty(PsiModifier.PRIVATE)) return true;
    return myCurrentFileContext instanceof PsiImportStatementBase;
  }

@@ -0,0 +1,5 @@
+class Foo {
+    {
+        ++nu<caret>
+    }
+}
@@ -0,0 +1,70 @@
+public class Main {
+    static interface A
+    {
+        interface B  { }
+    }
+
+    static class D implements A
+    {
+        private interface B { }
+    }
+
+
+    static class C extends D implements A
+    {
+        interface E extends B { }
+        interface E1 extends D.B { }
+        interface E2 extends A.B { }
+    }
+
+}
+
+
+
+class Main1 {
+    static interface A
+    {
+        interface B  { }
+    }
+
+    static class D implements A
+    {
+        interface B { }
+    }
+
+
+    static class C extends D implements A
+    {
+        interface E extends <error descr="Reference to 'B' is ambiguous, both 'Main1.D.B' and 'Main1.A.B' match">B</error> { }
+        interface E1 extends D.B {
+        }
+        interface E2 extends A.B { }
+    }
+
+}
+
+
+interface A
+{
+    interface B  { }
+    interface B1  { }
+}
+
+class D implements A
+{
+    private interface B { }
+    interface B1 { }
+}
+
+
+class C extends D implements A
+{
+    interface E extends B { }
+    interface E1 extends D.<error descr="'D.B' has private access in 'D'">B</error> { }
+    interface E2 extends A.B { }
+
+    interface F extends <error descr="Reference to 'B1' is ambiguous, both 'D.B1' and 'A.B1' match">B1</error> { }
+    interface F1 extends D.B1 { }
+    interface F2 extends A.B1 { }
+
+}
@@ -0,0 +1,3 @@
+class A<T extends <error descr="'A.B' has private access in 'A'">A<T>.B</error>> {
+    private class B {}
+}
@@ -539,6 +539,7 @@ public class ListUtils {
  }

  public void testNoThisInComment() throws Throwable { doAntiTest() }
+  public void testIncNull() throws Throwable { doAntiTest() }

  public void testLastExpressionInFor() throws Throwable { doTest(); }

@@ -87,6 +87,7 @@ public class LightAdvHighlightingJdk7Test extends LightDaemonAnalyzerTestCase {
  public void testDiamondNeg14() throws Exception { doTest(false, false); }
  public void testDiamondMisc() throws Exception { doTest(false, false); }
  public void testHighlightInaccessibleFromClassModifierList() throws Exception { doTest(false, false); }
+  public void testInnerInTypeArguments() throws Exception { doTest(false, false); }

  public void testDynamicallyAddIgnoredAnnotations() throws Exception {
    ExtensionPoint<EntryPoint> point = Extensions.getRootArea().getExtensionPoint(ExtensionPoints.DEAD_CODE_TOOL);
@@ -194,6 +194,7 @@ public class LightAdvHighlightingTest extends LightDaemonAnalyzerTestCase {
  public void testDefaultPackageClassInStaticImport() throws Exception { doTest(false, false); }

  public void testUnusedParamsOfPublicMethod() throws Exception { doTest(true, false); }
+  public void testInnerClassesShadowing() throws Exception { doTest(false, false); }

  public void testUnusedParamsOfPublicMethodDisabled() throws Exception {
    myUnusedSymbolLocalInspection.REPORT_PARAMETER_FOR_PUBLIC_METHODS = false;
@@ -20,6 +20,9 @@ import gnu.trove.TIntObjectProcedure;
 import gnu.trove.TIntProcedure;

 import java.io.PrintStream;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;

 /**
 * Created by IntelliJ IDEA.
@@ -63,15 +66,23 @@ abstract class IntIntMultiMaplet implements Streamable {
        stream.println(context.getValue(a));
        stream.println("  Values:");

+        final List<String> list = new LinkedList<String>();
+
        b.forEach(new TIntProcedure() {
          @Override
          public boolean execute(final int value) {
-            stream.print("    ");
-            stream.println(context.getValue(value));
-
+            list.add(context.getValue(value));
            return true;
          }
        });
+
+        Collections.sort(list);
+
+        for (final String l : list) {
+          stream.print("    ");
+          stream.println(l);
+        }
+
        stream.println("  End Of Values");
        return true;
      }
@@ -17,8 +17,12 @@ package org.jetbrains.ether.dependencyView;

 import gnu.trove.TIntObjectProcedure;

+import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;

 /**
 * Created by IntelliJ IDEA.
@@ -62,8 +66,21 @@ abstract class IntObjectMultiMaplet<V extends Streamable> implements Streamable
        stream.println(context.getValue(a));
        stream.println("  Values:");

+        final List<String> list = new LinkedList<String> ();
+
        for (final V value : b) {
-          value.toStream(context, stream);
+          final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+          final PrintStream s = new PrintStream(baos);
+
+          value.toStream(context, s);
+
+          list.add(baos.toString());
+        }
+
+        Collections.sort(list);
+
+        for (final String l : list) {
+          stream.print(l);
        }

        stream.println("  End Of Values");
@@ -35,6 +35,8 @@ public class ProjectScopeImpl extends GlobalSearchScope {
  public boolean contains(VirtualFile file) {
    if (file instanceof VirtualFileWindow) return true;

+    if (myFileIndex.isInLibraryClasses(file) && !myFileIndex.isInSourceContent(file)) return false;
+
    return myFileIndex.isInContent(file);
  }

@@ -460,7 +460,7 @@ public class LookupImpl extends LightweightHint implements LookupEx, Disposable
      updateListHeight(listModel);

      myList.setSelectedIndex(toSelect);
-      return Arrays.equals(oldModel, items.toArray());
+      return !Arrays.equals(oldModel, items.toArray());
    }

  }
@@ -1260,7 +1260,7 @@ public class LookupImpl extends LightweightHint implements LookupEx, Disposable
      }
      Rectangle rectangle = calculatePosition();
      myMaximumHeight = rectangle.height;
-      
+
      if (myResizePending || itemsChanged) {
        myResizePending = false;
        pack();
@@ -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.
@@ -20,13 +20,16 @@ import com.intellij.ide.actions.CopyAction;
 import com.intellij.ide.actions.CutAction;
 import com.intellij.openapi.actionSystem.*;
 import com.intellij.openapi.actionSystem.ex.AnActionListener;
+import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ModuleRootEvent;
 import com.intellij.openapi.roots.ModuleRootListener;
 import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.openapi.util.ActionCallback;
 import com.intellij.openapi.vcs.FileStatusListener;
 import com.intellij.openapi.vcs.FileStatusManager;
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.wm.IdeFocusManager;
 import com.intellij.problems.WolfTheProblemSolver;
 import com.intellij.psi.PsiManager;
 import com.intellij.psi.PsiTreeChangeEvent;
@@ -36,10 +39,7 @@ import org.jetbrains.annotations.NotNull;

 import javax.swing.*;
 import java.awt.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.awt.event.FocusEvent;
-import java.awt.event.FocusListener;
+import java.awt.event.*;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
 import java.util.List;
@@ -49,7 +49,7 @@ import java.util.List;
 */
 public class NavBarListener extends WolfTheProblemSolver.ProblemListener
  implements ActionListener, FocusListener, FileStatusListener, AnActionListener,
-             PsiTreeChangeListener, ModuleRootListener, NavBarModelListener, PropertyChangeListener {
+             PsiTreeChangeListener, ModuleRootListener, NavBarModelListener, PropertyChangeListener, KeyListener {
  private static final String LISTENER = "NavBarListener";
  private static final String BUS = "NavBarMessageBus";
  private final NavBarPanel myPanel;
@@ -71,6 +71,7 @@ public class NavBarListener extends WolfTheProblemSolver.ProblemListener
    connection.subscribe(ProjectTopics.PROJECT_ROOTS, listener);
    connection.subscribe(NavBarModelListener.NAV_BAR, listener);
    panel.putClientProperty(BUS, connection);
+    panel.addKeyListener(listener);
  }

  static void unsubscribeFrom(NavBarPanel panel) {
@@ -256,7 +257,46 @@ public class NavBarListener extends WolfTheProblemSolver.ProblemListener
           || action instanceof CutAction;
  }

+  @Override
+  public void keyPressed(final KeyEvent e) {
+    if (!(e.isAltDown() || e.isMetaDown() || e.isControlDown() || myPanel.isNodePopupActive())) {
+      if (!Character.isLetter(e.getKeyChar())) {
+        return;
+      }
+
+      final IdeFocusManager focusManager = IdeFocusManager.getInstance(myPanel.getProject());
+      final ActionCallback firstCharTyped = new ActionCallback();
+      focusManager.typeAheadUntil(firstCharTyped);
+      myPanel.moveDown();
+      ApplicationManager.getApplication().invokeLater(new Runnable() {
+        public void run() {
+          try {
+            final Robot robot = new Robot();
+            final boolean shiftOn = e.isShiftDown();
+            final int code = e.getKeyCode();
+            if (shiftOn) {
+              robot.keyPress(KeyEvent.VK_SHIFT);
+            }
+            robot.keyPress(code);
+            robot.keyRelease(code);
+
+            //don't release Shift
+            firstCharTyped.setDone();
+          }
+          catch (AWTException ignored) {
+          }
+        }
+      });
+    }
+  }
+
  //---- Ignored
+  @Override
+  public void keyTyped(KeyEvent e) {}
+
+  @Override
+  public void keyReleased(KeyEvent e) {}
+
  @Override
  public void beforeActionPerformed(AnAction action, DataContext dataContext, AnActionEvent event) {}

@@ -21,17 +21,15 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.roots.*;
 import com.intellij.openapi.roots.libraries.Library;
-import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.search.GlobalSearchScope;
-import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

-import java.util.Collections;
-import java.util.LinkedHashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;

 /**
@@ -39,7 +37,7 @@ import java.util.Set;
 */
 public class LibraryRuntimeClasspathScope extends GlobalSearchScope {
  private final ProjectFileIndex myIndex;
-  private final LinkedHashSet<VirtualFile> myEntries = new LinkedHashSet<VirtualFile>();
+  private final LinkedHashMap<VirtualFile, Integer> myEntries = new LinkedHashMap<VirtualFile, Integer>();

  public LibraryRuntimeClasspathScope(final Project project, final List<Module> modules) {
    super(project);
@@ -47,45 +45,68 @@ public class LibraryRuntimeClasspathScope extends GlobalSearchScope {
    final Set<Sdk> processedSdk = new THashSet<Sdk>();
    final Set<Library> processedLibraries = new THashSet<Library>();

-    ProjectRootManager.getInstance(project).orderEntries(modules).recursively().process(new RootPolicy<LinkedHashSet<VirtualFile>>() {
-          public LinkedHashSet<VirtualFile> visitLibraryOrderEntry(final LibraryOrderEntry libraryOrderEntry,
-                                                                   final LinkedHashSet<VirtualFile> value) {
-            final Library library = libraryOrderEntry.getLibrary();
-            if (library != null && processedLibraries.add(library)) {
-              ContainerUtil.addAll(value, libraryOrderEntry.getRootFiles(OrderRootType.CLASSES));
-            }
-            return value;
+    ProjectRootManager.getInstance(project).orderEntries(modules).recursively()
+      .process(new RootPolicy<LinkedHashMap<VirtualFile, Integer>>() {
+        @Override
+        public LinkedHashMap<VirtualFile, Integer> visitLibraryOrderEntry(final LibraryOrderEntry libraryOrderEntry,
+                                                                          final LinkedHashMap<VirtualFile, Integer> value) {
+          final Library library = libraryOrderEntry.getLibrary();
+          if (library != null && processedLibraries.add(library)) {
+            addAll(value, libraryOrderEntry.getRootFiles(OrderRootType.CLASSES));
          }
+          return value;
+        }

-          public LinkedHashSet<VirtualFile> visitModuleSourceOrderEntry(final ModuleSourceOrderEntry moduleSourceOrderEntry,
-                                                                        final LinkedHashSet<VirtualFile> value) {
-            ContainerUtil.addAll(value, moduleSourceOrderEntry.getFiles(OrderRootType.SOURCES));
-            return value;
-          }
+        @Override
+        public LinkedHashMap<VirtualFile, Integer> visitModuleSourceOrderEntry(final ModuleSourceOrderEntry moduleSourceOrderEntry,
+                                                                               final LinkedHashMap<VirtualFile, Integer> value) {
+          addAll(value, moduleSourceOrderEntry.getFiles(OrderRootType.SOURCES));
+          return value;
+        }

-          @Override
-          public LinkedHashSet<VirtualFile> visitModuleOrderEntry(ModuleOrderEntry moduleOrderEntry, LinkedHashSet<VirtualFile> value) {
-            final Module depModule = moduleOrderEntry.getModule();
-            if (depModule != null) {
-              ContainerUtil.addAll(value, ModuleRootManager.getInstance(depModule).getSourceRoots());
-            }
-            return value;
+        @Override
+        public LinkedHashMap<VirtualFile, Integer> visitModuleOrderEntry(ModuleOrderEntry moduleOrderEntry,
+                                                                         LinkedHashMap<VirtualFile, Integer> value) {
+          final Module depModule = moduleOrderEntry.getModule();
+          if (depModule != null) {
+            addAll(value, ModuleRootManager.getInstance(depModule).getSourceRoots());
          }
+          return value;
+        }

-          public LinkedHashSet<VirtualFile> visitJdkOrderEntry(final JdkOrderEntry jdkOrderEntry, final LinkedHashSet<VirtualFile> value) {
-            final Sdk jdk = jdkOrderEntry.getJdk();
-            if (jdk != null && processedSdk.add(jdk)) {
-              ContainerUtil.addAll(value, jdkOrderEntry.getRootFiles(OrderRootType.CLASSES));
-            }
-            return value;
+        @Override
+        public LinkedHashMap<VirtualFile, Integer> visitJdkOrderEntry(JdkOrderEntry jdkOrderEntry,
+                                                                      LinkedHashMap<VirtualFile, Integer> value) {
+          final Sdk jdk = jdkOrderEntry.getJdk();
+          if (jdk != null && processedSdk.add(jdk)) {
+            addAll(value, jdkOrderEntry.getRootFiles(OrderRootType.CLASSES));
          }
-        }, myEntries);
+          return value;
+        }
+      }, myEntries);
+
+    fillIndexes();
  }

  public LibraryRuntimeClasspathScope(Project project, LibraryOrderEntry entry) {
    super(project);
    myIndex = ProjectRootManager.getInstance(project).getFileIndex();
-    Collections.addAll(myEntries, entry.getRootFiles(OrderRootType.CLASSES));
+    addAll(myEntries, entry.getRootFiles(OrderRootType.CLASSES));
+
+    fillIndexes();
+  }
+
+  private void fillIndexes() {
+    int i = 0;
+    for (Map.Entry<VirtualFile, Integer> entry : myEntries.entrySet()) {
+      entry.setValue(i++);
+    }
+  }
+
+  private static void addAll(Map<VirtualFile, Integer> map, VirtualFile[] files) {
+    for (VirtualFile file : files) {
+      map.put(file, null);
+    }
  }

  public int hashCode() {
@@ -101,7 +122,7 @@ public class LibraryRuntimeClasspathScope extends GlobalSearchScope {
  }

  public boolean contains(VirtualFile file) {
-    return myEntries.contains(getFileRoot(file));
+    return myEntries.containsKey(getFileRoot(file));
  }

  @Nullable
@@ -121,11 +142,25 @@ public class LibraryRuntimeClasspathScope extends GlobalSearchScope {
  public int compare(VirtualFile file1, VirtualFile file2) {
    final VirtualFile r1 = getFileRoot(file1);
    final VirtualFile r2 = getFileRoot(file2);
-    for (VirtualFile root : myEntries) {
-      if (r1 == root) return 1;
-      if (r2 == root) return -1;
+
+    //for (VirtualFile root : myEntries) {
+    //  if (r1 == root) return 1;
+    //  if (r2 == root) return -1;
+    //}
+    //return 0;
+
+    Integer index1 = myEntries.get(r1);
+    Integer index2 = myEntries.get(r2);
+
+    if (index1 == null) {
+      return index2 == null ? 0 : -1;
    }
-    return 0;
+
+    if (index2 == null) {
+      return 1;
+    }
+
+    return index2.compareTo(index1);
  }

  public boolean isSearchInModuleContent(@NotNull Module aModule) {
@@ -138,6 +138,16 @@ public class IdeaApplication {
          setWM(xwm, "METACITY_WM");  // Mutter support absent - mimic Metacity
        }
      }
+      else if ("Muffin".equals(wmName)) {
+        // Muffin is completely unsupported at the moment - so mimic Mutter if possible, Metacity otherwise
+        try {
+          xwmClass.getDeclaredField("MUTTER_WM");
+          setWM(xwm, "MUTTER_WM");
+        }
+        catch (NoSuchFieldException e) {
+          setWM(xwm, "METACITY_WM");
+        }
+      }
      else if ("awesome".equals(wmName)) {
        try {
          xwmClass.getDeclaredField("OTHER_NONREPARENTING_WM");
@@ -640,6 +640,22 @@ public class Main {
    CompileServerManager.instance.shutdownServer()
  }

+  public void "_test make stub-level error and correct it"() {
+    def foo = myFixture.addFileToProject('Foo.groovy', 'class Foo { }')
+    myFixture.addFileToProject('Bar.java', 'class Bar extends Foo {}')
+
+    assertEmpty make()
+
+    setFileText(foo, 'class Foo implements Runnabl {}')
+
+    shouldFail { make() }
+
+    setFileText(foo, 'class Foo {}')
+
+    assertEmpty make()
+  }
+
+  //todo jeka: when recompiling module, delete all class files including those with excluded source
  public void "_test reporting module compile errors caused by missing files excluded from compilation"() {
    def foo = myFixture.addFileToProject('Foo.groovy', 'class Foo {}')
    myFixture.addFileToProject('Bar.groovy', 'class Bar extends Foo {}')