Updated to IDEA 132.27 EAP.

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetCodeBlockModificationListener.java

@@ -55,7 +55,7 @@ public class JetCodeBlockModificationListener implements PsiTreeChangePreprocess
 
             case CHILDREN_CHANGED:
                 // general childrenChanged() event after each change
-                if (!event.isGenericChildrenChange()) {
+                if (!event.isGenericChange()) {
                     processChange(event.getParent(), event.getParent(), null);
                 }
                 break;

idea/src/META-INF/plugin.xml

@@ -6,7 +6,7 @@
   <version>@snapshot@</version>
   <vendor url="http://www.jetbrains.com">JetBrains Inc.</vendor>
 
-  <idea-version since-build="130.1619" until-build="131.0"/>
+  <idea-version since-build="132.27" until-build="133.0"/>
 
   <depends optional="true" config-file="junit.xml">JUnit</depends>
   <depends optional="true" config-file="testng-j.xml">TestNG-J</depends>
@@ -281,7 +281,7 @@
 
     <referencesSearch implementation="org.jetbrains.jet.plugin.search.KotlinReferencesSearcher"/>
     <directClassInheritorsSearch implementation="org.jetbrains.jet.plugin.search.KotlinDirectInheritorsSearcher"/>
-    <definitionsSearch implementation="org.jetbrains.jet.plugin.search.KotlinDefinitionsSearcher"/>
+    <definitionsScopedSearch implementation="org.jetbrains.jet.plugin.search.KotlinDefinitionsSearcher"/>
     <annotatedElementsSearch implementation="org.jetbrains.jet.plugin.search.KotlinAnnotatedElementsSearcher"/>
 
     <exceptionFilter implementation="org.jetbrains.jet.plugin.filters.JetExceptionFilterFactory" order="first"/>

idea/src/META-INF/testng-j.xml

@@ -1,5 +1,5 @@
 <idea-plugin>
   <extensions defaultExtensionNs="com.intellij">
-    <configurationProducer implementation="org.jetbrains.jet.plugin.run.JetTestNgConfigurationProducer"/>
+    <runConfigurationProducer implementation="org.jetbrains.jet.plugin.run.JetTestNgConfigurationProducer"/>
   </extensions>
 </idea-plugin>

idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java

@@ -38,6 +38,7 @@ import com.intellij.openapi.ui.popup.JBPopupFactory;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.search.PsiElementProcessor;
 import com.intellij.psi.search.PsiElementProcessorAdapter;
 import com.intellij.psi.search.searches.AllOverridingMethodsSearch;
@@ -163,7 +164,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
 
             new LineMarkerNavigator() {
                 @Override
-                public void browse(@Nullable MouseEvent e, @Nullable PsiElement element) {
+                public void browse(@Nullable MouseEvent e, @Nullable final PsiElement element) {
                     if (element == null) return;
 
                     assert element.getParent() instanceof JetProperty : "This marker navigator should be placed only on identifies in properties";
@@ -181,7 +182,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
                     Runnable jetPsiMethodProcessor = new Runnable() {
                         @Override
                         public void run() {
-                            KotlinDefinitionsSearcher.processPropertyImplementationsMethods(psiPropertyMethods, elementProcessor);
+                            KotlinDefinitionsSearcher.processPropertyImplementationsMethods(psiPropertyMethods, GlobalSearchScope.allScope(element.getProject()), elementProcessor);
                         }
                     };
 

idea/src/org/jetbrains/jet/plugin/run/JetTestNgConfigurationProducer.java

@@ -19,10 +19,10 @@ package org.jetbrains.jet.plugin.run;
 import com.intellij.execution.JavaRunConfigurationExtensionManager;
 import com.intellij.execution.Location;
 import com.intellij.execution.PsiLocation;
-import com.intellij.execution.RunnerAndConfigurationSettings;
 import com.intellij.execution.actions.ConfigurationContext;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
@@ -31,35 +31,28 @@ import com.intellij.psi.util.PsiTreeUtil;
 import com.theoryinpractice.testng.configuration.TestNGConfiguration;
 import com.theoryinpractice.testng.configuration.TestNGConfigurationProducer;
 import com.theoryinpractice.testng.util.TestNGUtil;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.asJava.LightClassUtil;
 import org.jetbrains.jet.lang.psi.*;
 
 public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer {
-
-    public JetTestNgConfigurationProducer() {
-        super();
-    }
-
-    private JetElement myElement = null;
-
     @Override
-    public PsiElement getSourceElement() {
+    protected boolean setupConfigurationFromContext(
-        return myElement;
+            TestNGConfiguration configuration, ConfigurationContext context, Ref<PsiElement> sourceElement
-    }
+    ) {
-
-    @Override
-    @Nullable
-    protected RunnerAndConfigurationSettings createConfigurationByElement(Location location, ConfigurationContext context) {
         // TODO: check TestNG Pattern running first, before method/class (see TestNGInClassConfigurationProducer for logic)
         // TODO: and PsiClassOwner not handled, which is in TestNGInClassConfigurationProducer
 
-        Project project = location.getProject();
+        Location location = context.getLocation();
+        if (location == null) {
+            return false;
+        }
+
+        Project project = context.getProject();
         PsiElement leaf = location.getPsiElement();
 
         if (!(leaf.getContainingFile() instanceof JetFile)) {
-            return null;
+            return false;
         }
 
         JetFile jetFile = (JetFile) leaf.getContainingFile();
@@ -75,8 +68,7 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
                     for (PsiMethod method : delegate.getMethods()) {
                         if (method.getNavigationElement() == function) {
                             if (TestNGUtil.hasTest(method)) {
-                                myElement = function;
+                                return configure(configuration, location, context, project, delegate, method);
-                                return createRuntimeConfigSettings(location, context, project, delegate, method);
                             }
                             break;
                         }
@@ -92,27 +84,25 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
         }
 
         if (jetClass == null) {
-            return null;
+            return false;
         }
 
         PsiClass delegate = LightClassUtil.getPsiClass(jetClass);
         if (!isTestNGClass(delegate)) {
-            return null;
+            return false;
         }
 
-        myElement = jetClass;
+        return configure(configuration, location, context, project, delegate, null);
-        return createRuntimeConfigSettings(location, context, project, delegate, null);
     }
 
-    private RunnerAndConfigurationSettings createRuntimeConfigSettings(
+    private boolean configure(
-            Location location, ConfigurationContext context, Project project,
+            TestNGConfiguration configuration, Location location, ConfigurationContext context, Project project,
-            @Nullable PsiClass delegate, @Nullable PsiMethod method) {
+            @Nullable PsiClass delegate, @Nullable PsiMethod method
+    ) {
         if (delegate == null) {
-            return null;
+            return false;
         }
 
-        RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(project, context);
-        TestNGConfiguration configuration = (TestNGConfiguration) settings.getConfiguration();
         setupConfigurationModule(context, configuration);
         Module originalModule = configuration.getConfigurationModule().getModule();
         configuration.setClassConfiguration(delegate);
@@ -120,17 +110,12 @@ public class JetTestNgConfigurationProducer extends TestNGConfigurationProducer
             configuration.setMethodConfiguration(PsiLocation.fromPsiElement(project, method));
         }
         configuration.restoreOriginalModule(originalModule);
-        settings.setName(configuration.getName());
+        configuration.setName(configuration.getName());
         JavaRunConfigurationExtensionManager.getInstance().extendCreatedConfiguration(configuration, location);
-        return settings;
+        return true;
     }
 
     private static boolean isTestNGClass(PsiClass psiClass) {
         return psiClass != null && PsiClassUtil.isRunnableClass(psiClass, true, false) && TestNGUtil.hasTest(psiClass);
     }
-
-    @Override
-    public int compareTo(@NotNull Object o) {
-        return 0;
-    }
 }

idea/src/org/jetbrains/jet/plugin/search/KotlinDefinitionsSearcher.java

@@ -18,68 +18,77 @@ package org.jetbrains.jet.plugin.search;
 
 import com.intellij.codeInsight.navigation.MethodImplementationsSearch;
 import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.application.QueryExecutorBase;
 import com.intellij.openapi.util.Computable;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
+import com.intellij.psi.search.SearchScope;
 import com.intellij.psi.search.searches.ClassInheritorsSearch;
+import com.intellij.psi.search.searches.DefinitionsScopedSearch;
 import com.intellij.util.Processor;
+import com.intellij.util.QueryExecutor;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.asJava.LightClassUtil;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.java.JetClsMethod;
 
-public class KotlinDefinitionsSearcher extends QueryExecutorBase<PsiElement, PsiElement> {
+public class KotlinDefinitionsSearcher implements QueryExecutor<PsiElement, DefinitionsScopedSearch.SearchParameters> {
     @Override
-    public void processQuery(@NotNull PsiElement queryParameters, @NotNull Processor<PsiElement> consumer) {
+    public boolean execute(@NotNull DefinitionsScopedSearch.SearchParameters queryParameters, @NotNull Processor<PsiElement> consumer) {
-        if (queryParameters instanceof JetClass) {
+        PsiElement element = queryParameters.getElement();
-            processClassImplementations((JetClass) queryParameters, consumer);
+        SearchScope scope = queryParameters.getScope();
+
+        if (element instanceof JetClass) {
+            return processClassImplementations((JetClass) element, consumer);
         }
 
-        if (queryParameters instanceof JetNamedFunction) {
+        if (element instanceof JetNamedFunction) {
-            processFunctionImplementations((JetNamedFunction) queryParameters, consumer);
+            return processFunctionImplementations((JetNamedFunction) element, scope, consumer);
         }
 
-        if (queryParameters instanceof JetProperty) {
+        if (element instanceof JetProperty) {
-            processPropertyImplementations((JetProperty) queryParameters, consumer);
+            return processPropertyImplementations((JetProperty) element, scope, consumer);
         }
 
-        if (queryParameters instanceof JetParameter) {
+        if (element instanceof JetParameter) {
-            JetParameter parameter = (JetParameter) queryParameters;
+            JetParameter parameter = (JetParameter) element;
             if (JetPsiUtil.getClassIfParameterIsProperty(parameter) != null) {
-                processPropertyImplementations(parameter, consumer);
+                return processPropertyImplementations((JetParameter) element, scope, consumer);
             }
         }
-    }
 
-    private static void processClassImplementations(final JetClass queryParameters, Processor<PsiElement> consumer) {
+        return true;
+     }
+
+    private static boolean processClassImplementations(final JetClass klass, Processor<PsiElement> consumer) {
         PsiClass psiClass = ApplicationManager.getApplication().runReadAction(new Computable<PsiClass>() {
             @Override
             public PsiClass compute() {
-                return LightClassUtil.getPsiClass(queryParameters);
+                return LightClassUtil.getPsiClass(klass);
             }
         });
         if (psiClass != null) {
-            ContainerUtil.process(ClassInheritorsSearch.search(psiClass, true), consumer);
+            return ContainerUtil.process(ClassInheritorsSearch.search(psiClass, true), consumer);
         }
+        return true;
     }
 
-    private static void processFunctionImplementations(final JetNamedFunction queryParameters, Processor<PsiElement> consumer) {
+    private static boolean processFunctionImplementations(final JetNamedFunction function, SearchScope scope, Processor<PsiElement> consumer) {
         PsiMethod psiMethod = ApplicationManager.getApplication().runReadAction(new Computable<PsiMethod>() {
             @Override
             public PsiMethod compute() {
-                return LightClassUtil.getLightClassMethod(queryParameters);
+                return LightClassUtil.getLightClassMethod(function);
             }
         });
 
         if (psiMethod != null) {
-            ContainerUtil.process(MethodImplementationsSearch.getMethodImplementations(psiMethod), consumer);
+            ContainerUtil.process(MethodImplementationsSearch.getMethodImplementations(psiMethod, scope), consumer);
         }
+        return true;
     }
 
-    private static void processPropertyImplementations(@NotNull final JetParameter parameter, @NotNull Processor<PsiElement> consumer) {
+    private static boolean processPropertyImplementations(@NotNull final JetParameter parameter, @NotNull SearchScope scope, @NotNull Processor<PsiElement> consumer) {
         LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = ApplicationManager.getApplication().runReadAction(
                 new Computable<LightClassUtil.PropertyAccessorsPsiMethods>() {
                     @Override
@@ -88,10 +97,10 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase<PsiElement, Psi
                     }
                 });
 
-        processPropertyImplementationsMethods(accessorsPsiMethods, consumer);
+        return processPropertyImplementationsMethods(accessorsPsiMethods, scope, consumer);
     }
 
-    private static void processPropertyImplementations(@NotNull final JetProperty property, @NotNull Processor<PsiElement> consumer) {
+    private static boolean processPropertyImplementations(@NotNull final JetProperty property, @NotNull SearchScope scope, @NotNull Processor<PsiElement> consumer) {
         LightClassUtil.PropertyAccessorsPsiMethods accessorsPsiMethods = ApplicationManager.getApplication().runReadAction(
                 new Computable<LightClassUtil.PropertyAccessorsPsiMethods>() {
                     @Override
@@ -100,24 +109,31 @@ public class KotlinDefinitionsSearcher extends QueryExecutorBase<PsiElement, Psi
                     }
                 });
 
-        processPropertyImplementationsMethods(accessorsPsiMethods, consumer);
+        return processPropertyImplementationsMethods(accessorsPsiMethods, scope, consumer);
     }
 
-    public static void processPropertyImplementationsMethods(LightClassUtil.PropertyAccessorsPsiMethods accessors, @NotNull Processor<PsiElement> consumer) {
+    public static boolean processPropertyImplementationsMethods(LightClassUtil.PropertyAccessorsPsiMethods accessors, @NotNull SearchScope scope, @NotNull Processor<PsiElement> consumer) {
         for (PsiMethod method : accessors) {
-            PsiMethod[] implementations = MethodImplementationsSearch.getMethodImplementations(method);
+            PsiMethod[] implementations = MethodImplementationsSearch.getMethodImplementations(method, scope);
             for (PsiMethod implementation : implementations) {
                 PsiElement mirrorElement = implementation instanceof JetClsMethod ? ((JetClsMethod) implementation).getOrigin() : null;
                 if (mirrorElement instanceof JetProperty || mirrorElement instanceof JetParameter) {
-                    consumer.process(mirrorElement);
+                    if (!consumer.process(mirrorElement)) {
+                        return false;
+                    }
                 }
                 else if (mirrorElement instanceof JetPropertyAccessor && mirrorElement.getParent() instanceof JetProperty) {
-                    consumer.process(mirrorElement.getParent());
+                    if (!consumer.process(mirrorElement.getParent())) {
+                        return false;
+                    }
                 }
                 else {
-                    consumer.process(implementation);
+                    if (!consumer.process(implementation)) {
+                        return false;
+                    }
                 }
             }
         }
+        return true;
     }
 }

update_dependencies.xml

@@ -1,7 +1,7 @@
 <project name="Update Dependencies" default="update">
-    <property name="jb.buildserver.build.id" value="2030397"/>
+    <property name="jb.buildserver.build.id" value="2051374"/>
-    <property name="public.buildserver.build.id" value="89111"/>
+    <property name="public.buildserver.build.id" value="90345"/>
-    <property name="idea.archive.name" value="ideaIC-130.SNAPSHOT.win.zip"/>
+    <property name="idea.archive.name" value="ideaIC-132.SNAPSHOT.win.zip"/>
 
     <property name="idea.sdk.fetch.needed" value="true"/>